/*
 *  Copyright 2015 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.runtime.plugin;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.xml.XMLConstants;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;

import org.apache.avalon.framework.component.ComponentManager;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.service.WrapperServiceManager;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.XMLReader;

import org.ametys.runtime.config.ConfigDisableConditionsEvaluator;
import org.ametys.runtime.config.ConfigManager;
import org.ametys.runtime.model.type.ModelItemTypeExtensionPoint;
import org.ametys.runtime.plugin.FeatureActivator.PluginsInformation;
import org.ametys.runtime.plugin.IncludePolicyFeatureActivator.IncludedFeature;
import org.ametys.runtime.plugin.PluginIssue.PluginIssueCode;
import org.ametys.runtime.plugin.component.PluginsComponentManager;
import org.ametys.runtime.servlet.RuntimeConfig;

/**
 * The PluginManager is in charge to load and initialize plugins. <br>
 * It gives access to the extension points.
 */
public final class PluginsManager
{
    /** The regexp to determine if a plugin name is ignored (CVS or .* or *.bak or *.old)*/
    public static final String PLUGIN_NAMES_IGNORED = "^CVS|\\..+|.*\\.bak|.*\\.old$";
    
    /** The regexp to determine if a plugin name is correct (add ^ and $ as delimiters if this is your only test) */
    public static final String PLUGIN_NAME_REGEXP = "[a-zA-Z0-9](?:[a-zA-Z0-9-_\\.]*[a-zA-Z0-9])?";
    
    /** Separator between pluginName and featureName */
    public static final String FEATURE_ID_SEPARATOR = "/";

    /** Plugin filename */
    public static final String PLUGIN_FILENAME = "plugin.xml";
    
    /**
     * Context attribute containing the features to include.
     * <br>If present {@link PluginsManager} will init with {@link IncludePolicyFeatureActivator} and the provided collection of features (as strings).
     * <br>If not present, {@link PluginsManager} will init with {@link ExcludePolicyFeatureActivator} which is the default one.
     * <br>Use with care.
     */
    public static final String INCLUDED_FEATURES_CONTEXT_ATTRIBUTE = IncludePolicyFeatureActivator.IncludedFeature.class.getName();
    
    // Map runtimVersion -> XML schema
    private static final Map<String, String> __PLUGIN_SCHEMAS = Map.of("4.0", "plugin-4.0.xsd",
                                                                       "4.8", "plugin-4.8.xsd");

    // shared instance
    private static PluginsManager __instance;
    
    // safe mode flag
    private boolean _safeMode;
    
    // associations plugins/resourcesURI
    private Map<String, String> _resourceURIs;
    
    // plugins/locations association
    private Map<String, File> _locations;
    
    // All readable plugins
    private Map<String, Plugin> _allPlugins;

    // Active plugins
    private Map<String, Plugin> _plugins;

    // Plugin versions
    private Map<String, String> _versions;

    // Loaded features
    private Map<String, Feature> _features;

    // All inactive features
    private Map<String, InactivityStatus> _inactiveFeatures;

    // All declared extension points
    private Map<String, ExtensionPointDefinition> _extensionPoints;
    
    // Declared components, stored by role
    private Map<String, ComponentDefinition> _components;
    
    // Declared extension, grouped by extension point
    private Map<String, Map<String, ExtensionDefinition>> _extensions;
    
    // status after initialization
    private Status _status;
    
    // Logger for traces
    private Logger _logger = LoggerFactory.getLogger(PluginsManager.class);

    // Errors collected during system initialization
    private Collection<PluginIssue> _errors = new ArrayList<>();
    private FeatureActivator _featureActivator;

    private PluginsManager()
    {
        // empty constructor
    }
    
    /**
     * Returns the shared instance of the <code>PluginManager</code>
     * @return the shared instance of the PluginManager
     */
    public static PluginsManager getInstance()
    {
        if (__instance == null)
        {
            __instance = new PluginsManager();
        }

        return __instance;
    }
    
    /**
     * Returns true if the safe mode is activated.
     * @return true if the safe mode is activated.
     */
    public boolean isSafeMode()
    {
        return _safeMode;
    }
    
    /**
     * Returns errors gathered during plugins loading.
     * @return errors gathered during plugins loading.
     */
    public Collection<PluginIssue> getErrors()
    {
        return _errors;
    }

    /**
     * Returns the names of the plugins
     * @return the names of the plugins
     */
    public Set<String> getPluginNames()
    {
        return Collections.unmodifiableSet(_plugins.keySet());
    }
    
    /**
     * Determine if a given plugin is active
     * @param pluginName the plugin name
     * @return true if the plugin is active
     */
    public boolean isPluginActive(String pluginName)
    {
        return _plugins.containsKey(pluginName);
    }
    
    /**
     * Returns a String array containing the names of the plugins bundled in jars
     * @return a String array containing the names of the plugins bundled in jars
     */
    public Set<String> getBundledPluginsNames()
    {
        return Collections.unmodifiableSet(_resourceURIs.keySet());
    }

    /**
     * Returns active plugins declarations.
     * @return active plugins declarations.
     */
    public Map<String, Plugin> getPlugins()
    {
        return Collections.unmodifiableMap(_plugins);
    }

    /**
     * Returns all existing plugins definitions.
     * @return all existing plugins definitions.
     */
    public Map<String, Plugin> getAllPlugins()
    {
        return Collections.unmodifiableMap(_allPlugins);
    }
    
    /**
     * Returns loaded features declarations. <br>They may be different than active feature in case of safe mode.
     * @return loaded features declarations.
     */
    public Map<String, Feature> getFeatures()
    {
        return Collections.unmodifiableMap(_features);
    }
    
    /**
     * Returns inactive features id and cause of deactivation.
     * @return inactive features id and cause of deactivation.
     */
    public Map<String, InactivityStatus> getInactiveFeatures()
    {
        return Collections.unmodifiableMap(_inactiveFeatures);
    }

    /**
     * Returns the extensions points and their extensions
     * @return the extensions points and their extensions
     */
    public Map<String, Collection<String>> getExtensionPoints()
    {
        Map<String, Collection<String>> result = new HashMap<>();
        
        for (String point : _extensions.keySet())
        {
            result.put(point, _extensions.get(point).keySet());
        }
        
        return Collections.unmodifiableMap(result);
    }
    
    /**
     * Returns the components roles.
     * @return the components roles.
     */
    public Collection<String> getComponents()
    {
        return Collections.unmodifiableCollection(_components.keySet());
    }
    
    /**
     * Returns the base URI for the given plugin resources, or null if the plugin does not exist or is located in the file system.
     * @param pluginName the name of the plugin
     * @return the base URI for the given plugin resources, or null if the plugin does not exist or is located in the file system.
     */
    public String getResourceURI(String pluginName)
    {
        String pluginUri = _resourceURIs.get(pluginName);
        if (pluginUri == null || !_plugins.containsKey(pluginName))
        {
            return null;
        }
        
        return "resource:/" + pluginUri;
    }
    
    /**
     * Returns the plugin filesystem location for the given plugin or null if the plugin is loaded from the classpath.
     * @param pluginName the plugin name
     * @return the plugin location for the given plugin
     */
    public File getPluginLocation(String pluginName)
    {
        return _locations.get(pluginName);
    }
    
    /**
     * Get the plugin version or null if unknown. Only available for bundled plugins.
     * @param pluginName the plugin name
     * @return the plugin version if known.
     */
    public String getVersion(String pluginName)
    {
        return _versions.get(pluginName);
    }
    
    /**
     * Returns the status after initialization.
     * @return the status after initialization.
     */
    public Status getStatus()
    {
        return _status;
    }
    
    @SuppressWarnings("unchecked")
    private void _setActivator(Context context)
    {
        Collection<IncludedFeature> includedFeatures = null;
        try
        {
            includedFeatures = (Collection<IncludedFeature>) context.get(INCLUDED_FEATURES_CONTEXT_ATTRIBUTE);
        }
        catch (ContextException e)
        {
            // object not found
        }
        
        if (includedFeatures != null)
        {
            _featureActivator = new IncludePolicyFeatureActivator(_allPlugins, includedFeatures);
        }
        else
        {
            Collection<String> excludedPlugins = RuntimeConfig.getInstance().getExcludedPlugins();
            Collection<String> excludedFeatures = RuntimeConfig.getInstance().getExcludedFeatures();
            _featureActivator = new ExcludePolicyFeatureActivator(_allPlugins, excludedPlugins, excludedFeatures);
        }
        _logger.debug("Using FeatureActivator '{}'", _featureActivator.getClass().getSimpleName());
    }
    
    /**
     * Initialization of the plugin manager
     * @param parentCM the parent {@link ComponentManager}.
     * @param context the Avalon context
     * @param contextPath the Web context path on the server filesystem
     * @param forceSafeMode true to force the application to enter the safe mode
     * @return the {@link PluginsComponentManager} containing loaded components.
     * @throws Exception if something wrong occurs during plugins loading
     */
    public PluginsComponentManager init(ComponentManager parentCM, Context context, String contextPath, boolean forceSafeMode) throws Exception
    {
        _resourceURIs = new HashMap<>();
        _locations = new HashMap<>();
        _errors = new ArrayList<>();
        _versions = new HashMap<>();
        
        _safeMode = false;

        // Bundled plugins locations
        _initResourceURIs();
        
        // Additional plugins
        Map<String, File> externalPlugins = RuntimeConfig.getInstance().getExternalPlugins();
        
        // Check external plugins
        for (File plugin : externalPlugins.values())
        {
            if (!plugin.exists() || !plugin.isDirectory())
            {
                throw new RuntimeException("The configured external plugin is not an existing directory: " + plugin.getAbsolutePath());
            }
        }
        
        // Plugins root directories (directories containing plugins directories)
        Collection<String> locations = RuntimeConfig.getInstance().getPluginsLocations();
        
        // List of chosen components
        Map<String, String> componentsConfig = RuntimeConfig.getInstance().getComponents();
        
        // List of manually excluded plugins
        Collection<String> excludedPlugins = RuntimeConfig.getInstance().getExcludedPlugins();
        
        // Parse all plugin.xml
        _allPlugins = _parsePlugins(contextPath, locations, externalPlugins, excludedPlugins);

        if (RuntimeConfig.getInstance().isInvalid())
        {
            _status = Status.RUNTIME_NOT_LOADED;
            PluginsComponentManager safeManager = _enterSafeMode(parentCM, context, contextPath);
            return safeManager;
        }
        
        // Get active feature list
        _setActivator(context);
        PluginsInformation info = _featureActivator.computeActiveFeatures(componentsConfig, _safeMode);
        
        Map<String, Plugin> plugins = info.getPlugins();
        Map<String, Feature> features = info.getFeatures();
        _errors.addAll(info.getErrors());
        
        // At this point, extension points, active and inactive features are known
        if (_logger.isInfoEnabled())
        {
            String shortDump = _featureActivator.shortDump(info);
            if (!shortDump.isEmpty())
            {
                _logger.info("\n" + shortDump);
            }
        }
        if (_logger.isDebugEnabled())
        {
            _logger.debug("All declared plugins : \n\n" + _featureActivator.fullDump(info));
        }
        
        if (!_errors.isEmpty())
        {
            _status = Status.WRONG_DEFINITIONS;
            PluginsComponentManager manager = _enterSafeMode(parentCM, context, contextPath);
            return manager;
        }
        
        // Create the ComponentManager for config
        PluginsComponentManager configCM = new PluginsComponentManager(parentCM);
        configCM.setLogger(LoggerFactory.getLogger("org.ametys.runtime.plugin.manager"));
        configCM.contextualize(context);
        
        // Create the ComponentManager
        PluginsComponentManager manager = new PluginsComponentManager(configCM);
        manager.setLogger(LoggerFactory.getLogger("org.ametys.runtime.plugin.manager"));
        manager.contextualize(context);
        
        _initializeConfigurationComponentManager(contextPath, info, configCM);
        
        // Config loading
        ConfigManager configManager = ConfigManager.getInstance();
        
        configManager.contextualize(context);
        configManager.service(new WrapperServiceManager(configCM));
        configManager.initialize();
        
        _parseConfiguration(configManager, plugins, features);
        
        // force safe mode if requested
        if (forceSafeMode)
        {
            _status = Status.SAFE_MODE_FORCED;
            PluginsComponentManager safeManager = _enterSafeMode(parentCM, context, contextPath);
            return safeManager;
        }
        
        // config file does not exist
        if (configManager.isEmpty())
        {
            _status = Status.NO_CONFIG;
            PluginsComponentManager safeManager = _enterSafeMode(parentCM, context, contextPath);
            return safeManager;
        }
        
        if (!configManager.isComplete())
        {
            _status = Status.CONFIG_INCOMPLETE;
            PluginsComponentManager safeManager = _enterSafeMode(parentCM, context, contextPath);
            return safeManager;
        }
        
        // Components and single extension point loading
        Collection<PluginIssue> errors = new ArrayList<>();
        _loadExtensionsPoints(manager, info.getExtensionPoints(), info.getExtensions(), contextPath, errors);
        _loadComponents(manager, info.getComponents(), contextPath, errors);
        _loadRuntimeInit(manager, errors);
        
        _errors.addAll(errors);
        
        if (!errors.isEmpty())
        {
            _status = Status.NOT_INITIALIZED;
            PluginsComponentManager safeManager = _enterSafeMode(parentCM, context, contextPath);
            return safeManager;
        }
        
        _plugins = plugins;
        _features = features;
        _inactiveFeatures = info.getInactiveFeatures();
        _extensionPoints = info.getExtensionPoints();
        _extensions = info.getExtensions();
        _components = info.getComponents();
        
        try
        {
            manager.initialize();
        }
        catch (Exception e)
        {
            _logger.error("Caught an exception loading components.", e);
            
            _status = Status.NOT_INITIALIZED;
            
            _errors.add(new PluginIssue(null, null, PluginIssueCode.INITIALIZATION_EXCEPTION, null, e.getMessage(), e));

            // Dispose the first ComponentManager
            manager.dispose();
            manager = null;
            
            // Then enter safe mode with another ComponentManager
            PluginsComponentManager safeManager = _enterSafeMode(parentCM, context, contextPath);
            return safeManager;
        }
        
        _status = Status.OK;
        
        return manager;
    }

    private void _initializeConfigurationComponentManager(String contextPath, PluginsInformation pluginsInfo, PluginsComponentManager configCM)
    {
        Collection<PluginIssue> errorsOnConfigTypeEPLoading = new ArrayList<>();
        _loadExtensionsPoint(configCM, ModelItemTypeExtensionPoint.ROLE_CONFIG, pluginsInfo.getExtensionPoints(), pluginsInfo.getExtensions(), contextPath, errorsOnConfigTypeEPLoading);
        _loadComponent(configCM, ConfigDisableConditionsEvaluator.ROLE_FOR_CONFIG_EVALUATOR, pluginsInfo.getComponents(), contextPath, errorsOnConfigTypeEPLoading);
        
        _errors.addAll(errorsOnConfigTypeEPLoading);
        if (!errorsOnConfigTypeEPLoading.isEmpty())
        {
            throw new PluginException("Errors while loading extension points needed for configuration validation.", _errors, null);
        }
        
        try
        {
            configCM.initialize();
        }
        catch (Exception e)
        {
            throw new PluginException("Caught exception while starting ComponentManager for configuration validation.", e, _errors, null);
        }
    }

    private void _parseConfiguration(ConfigManager configManager, Map<String, Plugin> plugins, Map<String, Feature> features)
    {
        // Plugin (global) config parameter loading
        for (String pluginName : plugins.keySet())
        {
            Plugin plugin = plugins.get(pluginName);
            configManager.addPluginConfig(pluginName, plugin.getConfigParameters(), plugin.getParameterCheckers());
        }
        
        // Feature (local) config parameter loading
        for (String featureId : features.keySet())
        {
            Feature feature = features.get(featureId);
            configManager.addFeatureConfig(feature.getFeatureId(), feature.getConfigParameters(), feature.getParameterCheckers(), feature.getConfigParametersReferences());
        }
        
        // Parse the parameters and check if the config is complete and valid
        configManager.parseAndValidate();
    }
    
    // Look for plugins bundled in jars
    // They have a META-INF/ametys-plugins plain text file containing plugin name and path to plugin.xml
    private void _initResourceURIs() throws IOException
    {
        Enumeration<URL> pluginResources = getClass().getClassLoader().getResources("META-INF/ametys-plugins");
        
        while (pluginResources.hasMoreElements())
        {
            URL pluginResource = pluginResources.nextElement();
            
            try (InputStream is = pluginResource.openStream();
                 BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8")))
            {
                String plugin;
                while ((plugin = br.readLine()) != null)
                {
                    String pluginNameAndVersion = StringUtils.substringBefore(plugin, ':');
                    String pluginName = StringUtils.substringBefore(pluginNameAndVersion, '@');
                    String version = StringUtils.trimToNull(StringUtils.substringAfter(pluginNameAndVersion, '@'));
                    String pluginResourceURI = StringUtils.substringAfter(plugin, ':');
                    
                    _resourceURIs.put(pluginName, pluginResourceURI);
                    _versions.put(pluginName, version);
                }
            }
        }
    }
    
    private Map<String, Plugin> _parsePlugins(String contextPath, Collection<String> locations, Map<String, File> externalPlugins, Collection<String> excludedPlugins) throws IOException
    {
        Map<String, Plugin> plugins = new HashMap<>();
        
        // Bundled plugins configurations loading
        for (String pluginName : _resourceURIs.keySet())
        {
            String resourceURI = _resourceURIs.get(pluginName) + "/" + PLUGIN_FILENAME;
            
            if (getClass().getResource(resourceURI) == null)
            {
                _pluginError(pluginName, "A plugin '" + pluginName + "' is declared in a jar, but no file '" + PLUGIN_FILENAME + "' can be found at '" + resourceURI + "'.", PluginIssueCode.BUNDLED_PLUGIN_NOT_PRESENT, excludedPlugins, null);
            }
            else if (!pluginName.matches("^" + PLUGIN_NAME_REGEXP + "$"))
            {
                _pluginError(pluginName, pluginName + " is an incorrect plugin name.", PluginIssueCode.PLUGIN_NAME_INVALID, excludedPlugins, null);
            }
            else if (plugins.containsKey(pluginName))
            {
                _pluginError(pluginName, "The plugin " + pluginName + " at " + resourceURI + " is already declared.", PluginIssueCode.PLUGIN_NAME_EXIST, excludedPlugins, null);
            }

            _logger.debug("Reading plugin configuration at {}", resourceURI);

            Configuration configuration = null;
            String path = "resource:/" + resourceURI;
            try (InputStream is = getClass().getResourceAsStream(resourceURI))
            {
                configuration = _getConfigurationFromStream(pluginName, is, path, excludedPlugins);

                if (configuration != null)
                {
                    Plugin plugin = new Plugin(pluginName);
                    plugin.configure(configuration);
                    plugins.put(pluginName, plugin);
                    
                    _logger.info("Plugin '{}' found at path 'resource:/{}'", pluginName, resourceURI);
                }
            }
            catch (ConfigurationException e)
            {
                _pluginError(pluginName, "Unable to configure plugin '" + pluginName + "' at " + path, PluginIssueCode.CONFIGURATION_UNREADABLE, excludedPlugins, e);
            }
        }
        
        // Other plugins configuration loading
        for (String location : locations)
        {
            File locationBase = new File(contextPath, location);

            if (locationBase.exists() && locationBase.isDirectory())
            {
                File[] pluginDirs = locationBase.listFiles(new FileFilter()
                {
                    public boolean accept(File pathname)
                    {
                        return pathname.isDirectory();
                    }
                });
                
                for (File pluginDir : pluginDirs)
                {
                    _addPlugin(plugins, pluginDir.getName(), pluginDir, excludedPlugins);
                }
            }
        }
        
        // external plugins
        for (String externalPlugin : externalPlugins.keySet())
        {
            File pluginDir = externalPlugins.get(externalPlugin);

            if (pluginDir.exists() && pluginDir.isDirectory())
            {
                _addPlugin(plugins, externalPlugin, pluginDir, excludedPlugins);
            }
        }
        
        return plugins;
    }
    
    private void _addPlugin(Map<String, Plugin> plugins, String pluginName, File pluginDir, Collection<String> excludedPlugins) throws IOException
    {
        if (pluginName.matches(PLUGIN_NAMES_IGNORED))
        {
            _logger.debug("Skipping directory {} ...", pluginDir.getAbsolutePath());
            return;
        }
        
        if (!pluginName.matches("^" + PLUGIN_NAME_REGEXP + "$"))
        {
            _logger.warn("{} is an incorrect plugin directory name. It will be ignored.", pluginName);
            return;
        }
        
        File pluginFile = new File(pluginDir, PLUGIN_FILENAME);
        if (!pluginFile.exists())
        {
            _logger.warn("There is no file named {} in the directory {}. It will be ignored.", PLUGIN_FILENAME, pluginDir.getAbsolutePath());
            return;
        }

        if (plugins.containsKey(pluginName))
        {
            _pluginError(pluginName, "The plugin " + pluginName + " at " + pluginFile.getAbsolutePath() + " is already declared.", PluginIssueCode.PLUGIN_NAME_EXIST, excludedPlugins, null);
            return;
        }
        
        _logger.debug("Reading plugin configuration at {}", pluginFile.getAbsolutePath());

        Configuration configuration = null;
        String path = pluginFile.getAbsolutePath();
        try (InputStream is = new FileInputStream(pluginFile))
        {
            configuration = _getConfigurationFromStream(pluginName, is, path, excludedPlugins);

            if (configuration != null)
            {
                Plugin plugin = new Plugin(pluginName);
                plugin.configure(configuration);
                plugins.put(pluginName, plugin);
                
                _locations.put(pluginName, pluginDir);
                _logger.info("Plugin '{}' found at path '{}'", pluginName, pluginFile.getAbsolutePath());
            }
        }
        catch (ConfigurationException e)
        {
            _pluginError(pluginName, "Unable to configure plugin '" + pluginName + "' at " + path, PluginIssueCode.CONFIGURATION_UNREADABLE, excludedPlugins, e);
        }
    }

    private Configuration _getConfigurationFromStream(String pluginName, InputStream is, String path, Collection<String> excludedPlugins)
    {
        try
        {
            byte[] pluginConf = IOUtils.toByteArray(is);
            
            SAXParserFactory factory = SAXParserFactory.newInstance();
            factory.setNamespaceAware(true);
            XMLReader reader = factory.newSAXParser().getXMLReader();
            DefaultConfigurationBuilder confBuilder = new DefaultConfigurationBuilder(reader);

            Configuration configuration = confBuilder.build(new ByteArrayInputStream(pluginConf), path);
            
            String runtimeVersion = configuration.getAttribute("runtimeVersion", null);
            String schemaFile = __PLUGIN_SCHEMAS.get(runtimeVersion);
            
            if (schemaFile == null)
            {
                throw new IllegalArgumentException("Unknown runtimeVersion " + runtimeVersion + " for plugin at path " + path);
            }
            
            SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
            URL schemaURL = getClass().getResource(schemaFile);
            Schema schema = schemaFactory.newSchema(schemaURL);
            schema.newValidator().validate(new StreamSource(new ByteArrayInputStream(pluginConf)));
            
            return configuration;
        }
        catch (Exception e)
        {
            _pluginError(pluginName, "Unable to access to plugin '" + pluginName + "' at " + path, PluginIssueCode.CONFIGURATION_UNREADABLE, excludedPlugins, e);
            return null;
        }
    }
    
    private void _pluginError(String pluginName, String message, PluginIssueCode code, Collection<String> excludedPlugins, Exception e)
    {
        // ignore errors for manually excluded plugins
        if (!excludedPlugins.contains(pluginName))
        {
            PluginIssue issue = new PluginIssue(null, null, code, null, message, e);
            _errors.add(issue);
            _logger.error(message, e);
        }
    }
    
    private void _loadExtensionsPoint(PluginsComponentManager manager, String point, Map<String, ExtensionPointDefinition> extensionPoints, Map<String, Map<String, ExtensionDefinition>> extensionsDefinitions, String contextPath, Collection<PluginIssue> errors)
    {
        ExtensionPointDefinition definition = extensionPoints.get(point);
        Configuration conf = definition._configuration;
        String clazz = conf.getAttribute("class", null);
        String pluginName = definition._pluginName;
        
        try
        {
            Class<? extends Object> c = Class.forName(clazz);

            // check that the class is actually an ExtensionPoint
            if (ExtensionPoint.class.isAssignableFrom(c))
            {
                Class<? extends ExtensionPoint> extensionClass = c.asSubclass(ExtensionPoint.class);
                
                // Load extensions
                Collection<ExtensionDefinition> extensionDefinitions = new ArrayList<>();
                Map<String, ExtensionDefinition> initialDefinitions = extensionsDefinitions.get(point);
                
                if (initialDefinitions != null)
                {
                    for (String id : initialDefinitions.keySet())
                    {
                        ExtensionDefinition extensionDefinition = initialDefinitions.get(id);
                        Configuration initialConf = extensionDefinition.getConfiguration();
                        Configuration realExtensionConf = _getComponentConfiguration(initialConf, contextPath, extensionDefinition.getPluginName(), errors);
                        extensionDefinitions.add(new ExtensionDefinition(id, point, extensionDefinition.getPluginName(), extensionDefinition.getFeatureName(), realExtensionConf));
                    }
                }
                
                Configuration realComponentConf = _getComponentConfiguration(conf, contextPath, pluginName, errors);
                manager.addExtensionPoint(pluginName, point, extensionClass, realComponentConf, extensionDefinitions);
            }
            else
            {
                String message = "In plugin '" + pluginName + "', the extension point '" + point + "' references class '" + clazz + "' which don't implement " + ExtensionPoint.class.getName();
                _logger.error(message);
                PluginIssue issue = new PluginIssue(pluginName, null, PluginIssue.PluginIssueCode.EXTENSIONPOINT_CLASS_INVALID, conf.getLocation(), message);
                errors.add(issue);
            }
        }
        catch (ClassNotFoundException e)
        {
            String message = "In plugin '" + pluginName + "', the extension point '" + point + "' references the unexisting class '" + clazz + "'.";
            _logger.error(message, e);
            PluginIssue issue = new PluginIssue(pluginName, null, PluginIssue.PluginIssueCode.CLASSNOTFOUND, conf.getLocation(), message);
            errors.add(issue);
        }
    }

    private void _loadExtensionsPoints(PluginsComponentManager manager, Map<String, ExtensionPointDefinition> extensionPoints, Map<String, Map<String, ExtensionDefinition>> extensionsDefinitions, String contextPath, Collection<PluginIssue> errors)
    {
        extensionPoints.keySet()
                       .stream()
                       .filter(point -> !ModelItemTypeExtensionPoint.ROLE_CONFIG.equals(point)) // Point already loaded to parse config parameters
                       .forEach(point -> _loadExtensionsPoint(manager, point, extensionPoints, extensionsDefinitions, contextPath, errors));
    }
    
    @SuppressWarnings("unchecked")
    private void _loadComponent(PluginsComponentManager manager, String role, Map<String, ComponentDefinition> components, String contextPath, Collection<PluginIssue> errors)
    {
        ComponentDefinition componentDefinition = components.get(role);
        Configuration componentConf = componentDefinition.getConfiguration();
        Configuration realComponentConf = _getComponentConfiguration(componentConf, contextPath, componentDefinition.getPluginName(), errors);

        // XML schema ensures class is not null
        String clazz = componentConf.getAttribute("class", null);
        assert clazz != null;
        
        try
        {
            Class c = Class.forName(clazz);
            manager.addComponent(componentDefinition.getPluginName(), componentDefinition.getFeatureName(), role, c, realComponentConf);
        }
        catch (ClassNotFoundException ex)
        {
            String message = "In feature '" + componentDefinition.getPluginName() + FEATURE_ID_SEPARATOR + componentDefinition.getFeatureName() + "', the component '" + role + "' references the unexisting class '" + clazz + "'.";
            _logger.error(message, ex);
            PluginIssue issue = new PluginIssue(componentDefinition.getPluginName(), componentDefinition.getFeatureName(), PluginIssueCode.CLASSNOTFOUND, componentConf.getLocation(), message);
            errors.add(issue);
        }
    }
    
    private void _loadComponents(PluginsComponentManager manager, Map<String, ComponentDefinition> components, String contextPath, Collection<PluginIssue> errors)
    {
        components.keySet()
                  .stream()
                  .filter(role -> !ConfigDisableConditionsEvaluator.ROLE_FOR_CONFIG_EVALUATOR.equals(role)) // Component already loaded to parse config parameters
                  .forEach(role -> _loadComponent(manager, role, components, contextPath, errors));
    }
    
    private Configuration _getComponentConfiguration(Configuration initialConfiguration, String contextPath, String pluginName, Collection<PluginIssue> errors)
    {
        String config = initialConfiguration.getAttribute("config", null);
        
        if (config != null)
        {
            String configPath = null;
            
            try
            {
                // If the config attribute is present, it is either a plugin-relative, or a webapp-relative path (starting with '/')
                if (config.startsWith("/"))
                {
                    // absolute path
                    File configFile = new File(contextPath, config);
                    configPath = configFile.getAbsolutePath();
                    
                    if (!configFile.exists() || configFile.isDirectory())
                    {
                        if (_logger.isInfoEnabled())
                        {
                            _logger.info("No config file was found at " + configPath + ". Using internally declared config.");
                        }
                        
                        return initialConfiguration;
                    }
                    
                    try (InputStream is = new FileInputStream(configFile))
                    {
                        return new DefaultConfigurationBuilder(true).build(is, configPath);
                    }
                }
                else
                {
                    // relative path
                    String baseUri = _resourceURIs.get(pluginName);
                    if (baseUri == null)
                    {
                        File pluginLocation = getPluginLocation(pluginName);
                        
                        File configFile = new File(pluginLocation, config);
                        configPath = configFile.getAbsolutePath();

                        if (!configFile.exists() || configFile.isDirectory())
                        {
                            if (_logger.isInfoEnabled())
                            {
                                _logger.info("No config file was found at " + configPath + ". Using internally declared config.");
                            }
                            
                            return initialConfiguration;
                        }

                        try (InputStream is = new FileInputStream(configFile))
                        {
                            return new DefaultConfigurationBuilder(true).build(is, configPath);
                        }
                    }
                    else
                    {
                        String path = baseUri + "/" + config;
                        configPath = "resource:/" + path;
                        
                        try (InputStream is = getClass().getResourceAsStream(path))
                        {
                            if (is == null)
                            {
                                if (_logger.isInfoEnabled())
                                {
                                    _logger.info("No config file was found at " + configPath + ". Using internally declared config.");
                                }
                                
                                return initialConfiguration;
                            }
                            
                            return new DefaultConfigurationBuilder(true).build(is, configPath);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                String message = "Unable to load external configuration defined in the plugin " + pluginName;
                _logger.error(message, ex);
                PluginIssue issue = new PluginIssue(pluginName, null, PluginIssueCode.EXTERNAL_CONFIGURATION, initialConfiguration.getLocation(), message);
                errors.add(issue);
            }
        }
        
        return initialConfiguration;
    }

    private void _loadRuntimeInit(PluginsComponentManager manager, Collection<PluginIssue> errors)
    {
        String className = RuntimeConfig.getInstance().getInitClassName();

        if (className != null)
        {
            _logger.info("Loading init class '{}' for application", className);
            
            try
            {
                Class<?> initClass = Class.forName(className);
                if (!Init.class.isAssignableFrom(initClass))
                {
                    String message = "Provided init class " + initClass + " does not implement " + Init.class.getName();
                    _logger.error(message);
                    PluginIssue issue = new PluginIssue(null, null, PluginIssue.PluginIssueCode.INIT_CLASS_INVALID, null, message);
                    errors.add(issue);
                    return;
                }
                
                manager.addComponent(null, null, Init.ROLE, initClass, new DefaultConfiguration("component"));
                _logger.info("Init class {} loaded", className);
            }
            catch (ClassNotFoundException e)
            {
                String message = "The application init class '" + className + "' does not exist.";
                _logger.error(message, e);
                PluginIssue issue = new PluginIssue(null, null, PluginIssueCode.CLASSNOTFOUND, null, message);
                errors.add(issue);
            }
            
        }
        else if (_logger.isInfoEnabled())
        {
            _logger.info("No init class configured");
        }
    }
    
    private PluginsComponentManager _enterSafeMode(ComponentManager parentCM, Context context, String contextPath) throws Exception
    {
        _logger.info("Entering safe mode due to previous errors ...");
        _safeMode = true;
        
        ExcludePolicyFeatureActivator safeModeFeatureActivator = new ExcludePolicyFeatureActivator(_allPlugins, Collections.EMPTY_LIST, Collections.EMPTY_LIST);
        PluginsInformation info = safeModeFeatureActivator.computeActiveFeatures(Collections.EMPTY_MAP, _safeMode);
        
        _plugins = info.getPlugins();
        _extensionPoints = info.getExtensionPoints();
        _components = info.getComponents();
        _extensions = info.getExtensions();
        _features = info.getFeatures();
        _inactiveFeatures = info.getInactiveFeatures();
        
        if (_logger.isDebugEnabled())
        {
            _logger.debug("Safe mode : \n\n" + safeModeFeatureActivator.fullDump(info));
        }
        
        Collection<PluginIssue> errors = info.getErrors();
        if (!errors.isEmpty())
        {
            // errors while in safe mode ...
            throw new PluginException("Errors while loading components in safe mode.", _errors, errors);
        }
        
        // Create the ComponentManager for config
        PluginsComponentManager configCM = new PluginsComponentManager(parentCM);
        configCM.setLogger(LoggerFactory.getLogger("org.ametys.runtime.plugin.manager"));
        configCM.contextualize(context);

        // Create the ComponentManager
        PluginsComponentManager manager = new PluginsComponentManager(configCM);
        manager.setLogger(LoggerFactory.getLogger("org.ametys.runtime.plugin.manager"));
        manager.contextualize(context);
        
        _loadExtensionsPoint(configCM, ModelItemTypeExtensionPoint.ROLE_CONFIG, info.getExtensionPoints(), info.getExtensions(), contextPath, errors);
        _loadComponent(configCM, ConfigDisableConditionsEvaluator.ROLE_FOR_CONFIG_EVALUATOR, info.getComponents(), contextPath, errors);
        configCM.initialize();
        
        ConfigManager.getInstance().service(new WrapperServiceManager(configCM));

        errors = new ArrayList<>();
        _loadExtensionsPoints(manager, _extensionPoints, _extensions, contextPath, errors);
        _loadComponents(manager, _components, contextPath, errors);
        
        if (!errors.isEmpty())
        {
            // errors while in safe mode ...
            throw new PluginException("Errors while loading components in safe mode.", _errors, errors);
        }
        
        try
        {
            manager.initialize();
        }
        catch (Exception e)
        {
            throw new PluginException("Caught exception while starting ComponentManager in safe mode.", e, _errors, null);
        }
        
        return manager;
    }
    
    /**
     * Cause of the deactivation of a feature
     */
    public enum InactivityCause
    {
        /** Constant for excluded features */
        EXCLUDED,
        /** Constant for features deactivated by other features */
        DEACTIVATED,
        /** Constant for features overridden by another feature */
        OVERRIDDEN,
        /**Constant for features disabled due to not chosen component */
        COMPONENT,
        /** Constant for features disabled due to missing dependencies */
        DEPENDENCY,
        /** Constant for passive features that are not necessary (nobody depends on it) */
        PASSIVE,
        /** Constant for features disabled to wrong referenced extension point */
        INVALID_POINT,
        /** Feature is not safe while in safe mode */
        NOT_SAFE,
        /** Constant for features not enabled by {@link IncludePolicyFeatureActivator} (the feature is not needed as no enabled feature depends on it) */
        UNUSED
    }
    
    /**
     * PluginsManager status after initialization.
     */
    public enum Status
    {
        /** Everything is ok. All features were correctly loaded */
        OK,
        /** There was no errors, but the configuration is missing */
        NO_CONFIG,
        /** There was no errors, but the configuration is incomplete */
        CONFIG_INCOMPLETE,
        /** Something was wrong when reading plugins definitions */
        WRONG_DEFINITIONS,
        /** There were issues during components loading */
        NOT_INITIALIZED,
        /** The runtime.xml could not be loaded */
        RUNTIME_NOT_LOADED,
        /** Safe mode has been forced */
        SAFE_MODE_FORCED
    }
    
    /**
     * Represents the cause for an inactive feature, along with features causing the deactivation (overrides, ...)
     * @param cause the inactivity cause
     * @param features the features causing the inactivity, or null if none
     * 
     */
    public record InactivityStatus(InactivityCause cause, Collection<String> features) { /* empty */ }
}