/*
 *  Copyright 2018 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.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.runtime.plugin.PluginIssue.PluginIssueCode;
import org.ametys.runtime.plugin.PluginsManager.InactivityCause;
import org.ametys.runtime.servlet.RuntimeConfig;

/**
 * Basic impl
 */
public abstract class AbstractFeatureActivator implements FeatureActivator
{
    /** Logger */
    protected final Logger _logger = LoggerFactory.getLogger(this.getClass());
    /** Map of association identifier, plugin */
    protected final Map<String, Plugin> _allPlugins;
    /** true when in safe mode */
    protected boolean _safeMode;
    
    AbstractFeatureActivator(Map<String, Plugin> allPlugins)
    {
        _allPlugins = allPlugins;
    }
    
    /**
     * Compute the active plugins
     * @param excludedPlugins The excluded plugins
     * @param initialFeatures The features
     * @param inactiveFeatures The features that are inactive
     * @param extensionPoints The extension points
     * @param errors The issues
     * @return The active plugins
     */
    protected Map<String, Plugin> computeActivePlugins(
            Collection<String> excludedPlugins, 
            Map<String, Feature> initialFeatures, 
            Map<String, InactivityCause> inactiveFeatures, 
            Map<String, ExtensionPointDefinition> extensionPoints, 
            Collection<PluginIssue> errors)
    {
        Map<String, Plugin> plugins = new HashMap<>();
        for (String pluginName : _allPlugins.keySet())
        {
            if (!excludedPlugins.contains(pluginName))
            {
                Plugin plugin = _allPlugins.get(pluginName);
                plugins.put(pluginName, plugin);
                _logger.info("Plugin '{}' loaded", pluginName);

                // Check uniqueness of extension points
                Map<String, ExtensionPointDefinition> extPoints = plugin.getExtensionPointDefinitions();
                for (String point : extPoints.keySet())
                {
                    ExtensionPointDefinition definition = extPoints.get(point);
                    
                    if (!_safeMode || definition._safe)
                    {
                        if (extensionPoints.containsKey(point))
                        {
                            // It is an error to have two extension points with the same id, but we should not interrupt when in safe mode, so just ignore it
                            String message = "The extension point '" + point + "', defined in the plugin '" + pluginName + "' is already defined in another plugin. ";
                            PluginIssue issue = new PluginIssue(pluginName, null, PluginIssue.PluginIssueCode.EXTENSIONPOINT_ALREADY_EXIST, definition._configuration.getLocation(), message);
    
                            if (!_safeMode)
                            {
                                _logger.error(message);
                                errors.add(issue);
                            }
                            else
                            {
                                _logger.debug("[Safe mode] {}", message);
                            }
                        }
                        else
                        {
                            extensionPoints.put(point, definition);
                        }
                    }
                }
                
                Map<String, Feature> features = plugin.getFeatures();
                for (String id : features.keySet())
                {
                    Feature feature = features.get(id);
                    
                    if (!_safeMode || feature.isSafe())
                    {
                        initialFeatures.put(id, feature);
                    }
                    else
                    {
                        inactiveFeatures.put(id, InactivityCause.NOT_SAFE);
                    }
                }
            }
            else
            {
                _logger.debug("Plugin '{}' is excluded", pluginName);
            }
        }

        return plugins;
    }
    
    /**
     * Compute incoming deactivations
     * @param features The features
     * @return The deactivations
     */
    protected Map<String, Collection<String>> computeIncomingDeactivations(Map<String, Feature> features)
    {
        Map<String, Collection<String>> incomingDeactivations = new HashMap<>();
        
        for (String id : features.keySet())
        {
            Feature feature = features.get(id);
            Collection<String> deactivations = feature.getDeactivations();
            
            for (String deactivation : deactivations)
            {
                Collection<String> deps = incomingDeactivations.get(deactivation);
                if (deps == null)
                {
                    deps = new ArrayList<>();
                    incomingDeactivations.put(deactivation, deps);
                }
                
                deps.add(id);
            }
        }
        
        return incomingDeactivations;
    }
    
    /**
     * Remove inactive features
     * @param initialFeatures The initial features
     * @param inactiveFeatures The inactive features
     * @param incomingDeactivations The deactivations
     * @param componentsConfig The components
     */
    protected void removeInactiveFeatures(
            Map<String, Feature> initialFeatures, 
            Map<String, InactivityCause> inactiveFeatures, 
            Map<String, Collection<String>> incomingDeactivations, 
            Map<String, String> componentsConfig)
    {
        Iterator<String> it = initialFeatures.keySet().iterator();
        while (it.hasNext())
        {
            String id = it.next();
            Feature feature = initialFeatures.get(id);
            
            if (incomingDeactivations.containsKey(id) && !incomingDeactivations.get(id).isEmpty())
            {
                String deactivatingFeature = incomingDeactivations.get(id).iterator().next();
                _logger.debug("Removing feature {} deactivated by feature {}.", id, deactivatingFeature);
                it.remove();
                inactiveFeatures.put(id, InactivityCause.DEACTIVATED);
                continue;
            }
            
            Map<String, String> components = feature.getComponentsIds();
            for (String role : components.keySet())
            {
                String componentId = components.get(role);
                String selectedId = componentsConfig.get(role);
                
                // remove the feature if the user asked for a specific id and the declared component has not that id 
                if (selectedId != null && !selectedId.equals(componentId))
                {
                    _logger.debug("Removing feature '{}' as it contains the component id '{}' for role '{}' but the user selected the id '{}' for that role.", id, componentId, role, selectedId);
                    it.remove();
                    inactiveFeatures.put(id, InactivityCause.COMPONENT);
                    continue;
                }
            }
        }
    }
    
    /**
     * Remove the wrong points
     * @param initialFeatures The initial features
     * @param inactiveFeatures The inactive features
     * @param extensionPoints The extension points
     * @param errors The errors
     */
    protected void removeWrongPointReferences(
            Map<String, Feature> initialFeatures, 
            Map<String, InactivityCause> inactiveFeatures, 
            Map<String, ExtensionPointDefinition> extensionPoints, 
            Collection<PluginIssue> errors)
    {
        Set<String> ids = initialFeatures.keySet();
        Iterator<String> it = ids.iterator();
        while (it.hasNext())
        {
            String id = it.next();
            Feature feature = initialFeatures.get(id);
            Map<String, Collection<String>> extensionsIds = feature.getExtensionsIds();
            boolean hasBeenRemoved = false;
            for (String point : extensionsIds.keySet())
            {
                if (!extensionPoints.containsKey(point))
                {
                    String message = "In feature '" + id + "' an extension references the non-existing point '" + point + "'.";
                    _logger.error(message);
                    PluginIssue issue = new PluginIssue(feature.getPluginName(), feature.getFeatureName(), PluginIssueCode.INVALID_POINT, null, message);
                    errors.add(issue);
                    if (!hasBeenRemoved)
                    {
                        it.remove();
                        inactiveFeatures.put(id, InactivityCause.INVALID_POINT);
                        hasBeenRemoved = true;
                    }
                }
            }
        }
    }
    
    /**
     * Process the outgoing dependencies
     * @param initialFeatures The initial features
     * @param inactiveFeatures The inactive features
     * @param errors The errors
     * @return the outgoing dependencies
     */
    protected Map<String, Feature> processOutgoingDependencies(
            Map<String, Feature> initialFeatures, 
            Map<String, InactivityCause> inactiveFeatures, 
            Collection<PluginIssue> errors)
    {
        // Check outgoing dependencies
        boolean processDependencies = true;
        while (processDependencies)
        {
            processDependencies = false;
            
            Collection<String> ids = initialFeatures.keySet();
            Iterator<String> it = ids.iterator();
            while (it.hasNext())
            {
                String id = it.next();
                Feature feature = initialFeatures.get(id);
                Collection<String> dependencies = feature.getDependencies();
                for (String dependency : dependencies)
                {
                    if (!initialFeatures.containsKey(dependency))
                    {
                        _logger.debug("The feature '{}' depends on '{}' which is not present. It will be ignored.", id, dependency);
                        it.remove();
                        inactiveFeatures.put(id, InactivityCause.DEPENDENCY);
                        processDependencies = true;
                        break; // end iterate over dependencies (avoid a potential second it.remove() which will throw exception) and continue the while loop
                    }
                }
            }
        }
        
        // Reorder remaining features, respecting dependencies
        Map<String, Feature> resultFeatures = new LinkedHashMap<>();
        
        for (String featureId : initialFeatures.keySet())
        {
            _computeFeaturesDependencies(featureId, initialFeatures, resultFeatures, featureId, errors);
        }
        
        return resultFeatures;
    }
    
    private void _computeFeaturesDependencies(
            String featureId, 
            Map<String, Feature> initialFeatures, 
            Map<String, Feature> resultFeatures, 
            String initialFeatureId, 
            Collection<PluginIssue> errors)
    {
        Feature feature = initialFeatures.get(featureId);
        Collection<String> dependencies = feature.getDependencies();
        
        for (String dependency : dependencies)
        {
            if (initialFeatureId.equals(dependency))
            {
                String message = "Circular dependency detected for feature: " + feature.getFeatureId();
                _logger.error(message);
                PluginIssue issue = new PluginIssue(feature.getPluginName(), feature.getFeatureName(), PluginIssueCode.CIRCULAR_DEPENDENCY, null, message);
                errors.add(issue);
            }
            else if (!resultFeatures.containsKey(dependency))
            {
                // do not process the feature if it has already been processed
                _computeFeaturesDependencies(dependency, initialFeatures, resultFeatures, initialFeatureId, errors);
            }
        }
        
        resultFeatures.put(featureId, feature);
    }
    
    /**
     * Compute incoming dependencies
     * @param features The features
     * @return The dependencies
     */
    protected Map<String, Collection<String>> computeIncomingDependencies(Map<String, Feature> features)
    {
        Map<String, Collection<String>> incomingDependencies = new HashMap<>();
        for (String id : features.keySet())
        {
            Feature feature = features.get(id);
            Collection<String> dependencies = feature.getDependencies();
            
            for (String dependency : dependencies)
            {
                Collection<String> deps = incomingDependencies.get(dependency);
                if (deps == null)
                {
                    deps = new ArrayList<>();
                    incomingDependencies.put(dependency, deps);
                }
                
                deps.add(id);
            }
        }
        
        return incomingDependencies;
    }
    
    /**
     * Compute the outgoing dependencies
     * @param features The features
     * @return The dependencies
     */
    protected Map<String, Collection<String>> computeOutgoingDependencies(Map<String, Feature> features)
    {
        Map<String, Collection<String>> outgoingDependencies = new HashMap<>();
        for (String id : features.keySet())
        {
            Feature feature = features.get(id);
            Collection<String> dependencies = feature.getDependencies();
            outgoingDependencies.put(id, dependencies);
        }
        
        return outgoingDependencies;
    }
    
    /**
     * Remove the unused features that were declared passive
     * @param features The features
     * @param inactiveFeatures The inactive features
     * @param incomingDependencies The dependencies
     */
    protected void removeUnusedPassiveFeatures(
            Map<String, Feature> features, 
            Map<String, InactivityCause> inactiveFeatures, 
            Map<String, Collection<String>> incomingDependencies)
    {
        Set<String> ids = features.keySet();
        Iterator<String> it = ids.iterator();
        while (it.hasNext())
        {
            String id = it.next();
            Feature feature = features.get(id);
            
            if (feature.isPassive() && !incomingDependencies.containsKey(id))
            {
                _logger.debug("Remove passive feature '{}'", id);
                it.remove();
                inactiveFeatures.put(id, InactivityCause.PASSIVE);
            }
        }
    }
    
    /**
     * Compute the extensions
     * @param features The features
     * @param errors The errors
     * @return The extensions
     */
    protected Map<String, Map<String, ExtensionDefinition>> computeExtensions(
            Map<String, Feature> features, 
            Collection<PluginIssue> errors)
    {
        Map<String, Map<String, ExtensionDefinition>> extensionsDefinitions = new HashMap<>();
        for (Feature feature : features.values())
        {
            // extensions
            Map<String, Map<String, ExtensionDefinition>> extensionsConfs = feature.getExtensions();
            for (String point : extensionsConfs.keySet())
            {
                Map<String, ExtensionDefinition> featureExtensions = extensionsConfs.get(point);
                Map<String, ExtensionDefinition> globalExtensions = extensionsDefinitions.get(point);
                if (globalExtensions == null)
                {
                    globalExtensions = new LinkedHashMap<>(featureExtensions);
                    extensionsDefinitions.put(point, globalExtensions);
                }
                else
                {
                    for (String id : featureExtensions.keySet())
                    {
                        if (globalExtensions.containsKey(id))
                        {
                            String message = "The extension '" + id + "' to point '" + point + "' is already defined in another feature.";
                            _logger.error(message);
                            PluginIssue issue = new PluginIssue(feature.getPluginName(), feature.getFeatureName(), PluginIssueCode.EXTENSION_ALREADY_EXIST, null, message);
                            errors.add(issue);
                        }
                        else
                        {
                            ExtensionDefinition definition = featureExtensions.get(id);
                            globalExtensions.put(id, definition);
                        }
                    }
                }
            }
        }
        
        return extensionsDefinitions;
    }
    
    /**
     * compute the components
     * @param features The features
     * @param componentsConfig The component configurations
     * @param errors The errors
     * @return The components
     */
    protected Map<String, ComponentDefinition> computeComponents(
            Map<String, Feature> features, 
            Map<String, String> componentsConfig, 
            Collection<PluginIssue> errors)
    {
        Map<String, ComponentDefinition> components = new HashMap<>();
        
        for (Feature feature : features.values())
        {
            // components
            Map<String, ComponentDefinition> featureComponents = feature.getComponents();
            for (String role : featureComponents.keySet())
            {
                ComponentDefinition definition = featureComponents.get(role);
                ComponentDefinition globalDefinition = components.get(role);
                if (globalDefinition == null)
                {
                    components.put(role, definition);
                }
                else
                {
                    String id = definition.getId();
                    if (id.equals(globalDefinition.getId()))
                    {
                        String message = "The component for role '" + role + "' and id '" + id + "' is defined both in feature '" + definition.getPluginName() + PluginsManager.FEATURE_ID_SEPARATOR + definition.getFeatureName() + "' and in feature '" + globalDefinition.getPluginName() + PluginsManager.FEATURE_ID_SEPARATOR + globalDefinition.getFeatureName() + "'.";
                        _logger.error(message);
                        PluginIssue issue = new PluginIssue(feature.getPluginName(), feature.getFeatureName(), PluginIssueCode.COMPONENT_ALREADY_EXIST, null, message);
                        errors.add(issue);
                    }
                    else
                    {
                        String message = "The component for role '" + role + "' is defined with id '" + id + "' in the feature '" + definition.getPluginName() + PluginsManager.FEATURE_ID_SEPARATOR + definition.getFeatureName() + "' and with id '" + globalDefinition.getId() + "' in the feature '" + globalDefinition.getPluginName() + PluginsManager.FEATURE_ID_SEPARATOR + globalDefinition.getFeatureName() + "'. One of them should be chosen in the runtime.xml.";
                        _logger.error(message);
                        PluginIssue issue = new PluginIssue(feature.getPluginName(), feature.getFeatureName(), PluginIssueCode.COMPONENT_ALREADY_EXIST, null, message);
                        errors.add(issue);
                    }
                }
            }
        }
        
        // check that each component choosen in the runtime.xml is actually defined
        for (String role : componentsConfig.keySet())
        {
            String requiredId = componentsConfig.get(role);
            ComponentDefinition definition = components.get(role);
            
            if (definition == null || !definition.getId().equals(requiredId))
            {
                // Due to preceding checks, the definition id should not be different than requiredId, but two checks are always better than one ...
                String message = "The component for role '" + role + "' should point to id '" + requiredId + "' but no component match.";
                _logger.error(message);
                PluginIssue issue = new PluginIssue(null, null, PluginIssueCode.COMPONENT_NOT_DECLARED, null, message);
                errors.add(issue);
            }
        }
        
        return components;
    }
    
    @Override
    public String fullDump(PluginsInformation pluginInfo)
    {
        Map<String, InactivityCause> inactiveFeatures = pluginInfo.getInactiveFeatures();
        Collection<PluginIssue> errors = pluginInfo.getErrors();
        
        Collection<String> excludedPlugins = RuntimeConfig.getInstance().getExcludedPlugins();
        StringBuilder sb = new StringBuilder();
        
        for (String pluginName : _allPlugins.keySet())
        {
            Plugin plugin = _allPlugins.get(pluginName);
            _dumpPlugin(sb, plugin, excludedPlugins, inactiveFeatures);
        }
        
        if (!errors.isEmpty())
        {
            sb.append("\nErrors :\n");
            errors.forEach(issue -> sb.append(issue.toString()).append('\n'));
        }
        
        return sb.toString();
    }
    
    private void _dumpPlugin(StringBuilder sb, Plugin plugin, Collection<String> excludedPlugins, Map<String, InactivityCause> inactiveFeatures)
    {
        String pluginName = plugin.getName();
        sb.append("Plugin ").append(pluginName);
        
        if (excludedPlugins.contains(pluginName))
        {
            sb.append("   *** excluded ***");
        }
        
        sb.append('\n');
        
        Collection<String> configParameters = plugin.getConfigParameters().keySet();
        if (!CollectionUtils.isEmpty(configParameters))
        {
            sb.append("  Config parameters : \n");
            configParameters.forEach(param -> sb.append("    ").append(param).append('\n'));
        }
        
        Collection<String> paramCheckers = plugin.getParameterCheckers().keySet();
        if (!CollectionUtils.isEmpty(paramCheckers))
        {
            sb.append("  Parameters checkers : \n");
            paramCheckers.forEach(param -> sb.append("    ").append(param).append('\n'));
        }
        
        Collection<String> extensionPoints = plugin.getExtensionPoints();
        if (!CollectionUtils.isEmpty(extensionPoints))
        {
            sb.append("  Extension points : \n");
            extensionPoints.forEach(point -> sb.append("    ").append(point).append('\n'));
        }
        
        Map<String, Feature> features = plugin.getFeatures();
        for (String featureId : features.keySet())
        {
            Feature feature = features.get(featureId);
            _dumpFeature(sb, feature, inactiveFeatures);
        }
        
        sb.append('\n');
    }
    
    private void _dumpFeature(StringBuilder sb, Feature feature, Map<String, InactivityCause> inactiveFeatures)
    {
        String featureId = feature.getFeatureId();
        
        sb.append("  Feature ").append(featureId);
        if (feature.isPassive())
        {
            sb.append(" (passive)");
        }

        if (feature.isSafe())
        {
            sb.append(" (safe)");
        }
        
        if (inactiveFeatures != null && inactiveFeatures.containsKey(featureId))
        {
            sb.append("   *** inactive (").append(inactiveFeatures.get(featureId)).append(") ***");
        }
        
        sb.append('\n');
        
        Collection<String> featureConfigParameters = feature.getConfigParameters().keySet();
        if (!CollectionUtils.isEmpty(featureConfigParameters))
        {
            sb.append("    Config parameters : \n");
            featureConfigParameters.forEach(param -> sb.append("      ").append(param).append('\n'));
        }
        
        Collection<String> configParametersReferences = feature.getConfigParametersReferences();
        if (!CollectionUtils.isEmpty(configParametersReferences))
        {
            sb.append("    Config parameters references : \n");
            configParametersReferences.forEach(param -> sb.append("      ").append(param).append('\n'));
        }
        
        Collection<String> featureParamCheckers = feature.getParameterCheckers().keySet();
        if (!CollectionUtils.isEmpty(featureParamCheckers))
        {
            sb.append("    Parameters checkers : \n");
            featureParamCheckers.forEach(param -> sb.append("    ").append(param).append('\n'));
        }
        
        Map<String, String> componentsIds = feature.getComponentsIds();
        if (!componentsIds.isEmpty())
        {
            sb.append("    Components : \n");
            
            for (String role : componentsIds.keySet())
            {
                String id = componentsIds.get(role);
                sb.append("      ").append(role).append(" : ").append(id).append('\n');
            }
            
            sb.append('\n');
        }

        Map<String, Collection<String>> extensionsIds = feature.getExtensionsIds();
        if (!extensionsIds.isEmpty())
        {
            sb.append("    Extensions : \n");
            
            for (Entry<String, Collection<String>> extensionEntry : extensionsIds.entrySet())
            {
                String point = extensionEntry.getKey();
                Collection<String> ids = extensionEntry.getValue();
                
                sb.append("      ").append(point).append(" :\n");
                ids.forEach(id -> sb.append("        ").append(id).append('\n'));
            }
            
            sb.append('\n');
        }
    }
}