/*
 *  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.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.collections4.ListUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.runtime.plugin.IncomingDeactivation.Type;
import org.ametys.runtime.plugin.PluginIssue.PluginIssueCode;
import org.ametys.runtime.plugin.PluginsManager.InactivityCause;
import org.ametys.runtime.plugin.PluginsManager.InactivityStatus;

/**
 * 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;
    /** the computed and corrected dependencies */
    protected CorrectedDependencies _correctedDependencies;
    
    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, InactivityStatus> 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, new InactivityStatus(InactivityCause.NOT_SAFE, null));
                    }
                }
            }
            else
            {
                _logger.debug("Plugin '{}' is excluded", pluginName);
            }
        }

        return plugins;
    }
    
    /**
     * Compute incoming deactivations
     * @param features The features
     * @return The deactivations
     */
    protected Map<String, Collection<IncomingDeactivation>> computeIncomingDeactivations(Map<String, Feature> features)
    {
        Map<String, Collection<IncomingDeactivation>> incomingDeactivations = new HashMap<>();
        
        for (String id : features.keySet())
        {
            Feature feature = features.get(id);
            Collection<String> deactivations = feature.getDeactivations();
            _fillDeactivationsByFeature(id, deactivations, incomingDeactivations);
            Collection<String> overrides = feature.getOverrides();
            _fillOverridesByFeature(id, overrides, incomingDeactivations);
        }
        
        _checkNoMultipleOverriders(incomingDeactivations);
        
        return incomingDeactivations;
    }
    
    private void _fillDeactivationsByFeature(String featureIdTriggeringDeactivation, Collection<String> deactivations, Map<String, Collection<IncomingDeactivation>> incomingDeactivations)
    {
        for (String deactivatedFeature : deactivations)
        {
            Collection<IncomingDeactivation> deps = incomingDeactivations.computeIfAbsent(deactivatedFeature, __ -> new ArrayList<>());
            deps.add(new IncomingDeactivation(Type.DEACTIVATED, featureIdTriggeringDeactivation));
        }
    }
    
    private void _fillOverridesByFeature(String featureIdTriggeringOverride, Collection<String> overrides, Map<String, Collection<IncomingDeactivation>> incomingDeactivations)
    {
        for (String overriddenFeature : overrides)
        {
            Collection<IncomingDeactivation> deps = incomingDeactivations.computeIfAbsent(overriddenFeature, __ -> new ArrayList<>());
            deps.add(new IncomingDeactivation(Type.OVERRIDDEN, featureIdTriggeringOverride));
        }
    }
    
    private void _checkNoMultipleOverriders(Map<String, Collection<IncomingDeactivation>> incomingDeactivations)
    {
        for (Map.Entry<String, Collection<IncomingDeactivation>> incomingDeactivation : incomingDeactivations.entrySet())
        {
            Collection<IncomingDeactivation> overriders = incomingDeactivation.getValue()
                    .stream()
                    .filter(deactivator -> deactivator.getType() == Type.OVERRIDDEN)
                    .collect(Collectors.toList());
            if (overriders.size() > 1)
            {
                String overriddenFeature = incomingDeactivation.getKey();
                // has 2 or more overrides
                throw new IllegalStateException(String.format(
                        "Feature '%s' is overridden by %s. It cannot be overridden by 2 features. The application will not be able to boot.",
                        overriddenFeature, overriders));
            }
        }
    }
    
    /**
     * 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, InactivityStatus> inactiveFeatures, 
            Map<String, Collection<IncomingDeactivation>> 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))
            {
                Collection<IncomingDeactivation> deactivations = incomingDeactivations.get(id);
                if (!deactivations.isEmpty())
                {
                    _logger.debug("Removing feature {} deactivated by features {}.", id, deactivations);
                    it.remove();
                    Collection<String> sources = deactivations.stream().map(IncomingDeactivation::getFeatureId).toList();
                    inactiveFeatures.put(id, new InactivityStatus(_getCause(deactivations), sources));
                    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, new InactivityStatus(InactivityCause.COMPONENT, null));
                    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, InactivityStatus> 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, new InactivityStatus(InactivityCause.INVALID_POINT, null));
                        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, InactivityStatus> 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();
                if (_processOutgoingDependenciesForFeature(it, initialFeatures, inactiveFeatures, id))
                {
                    processDependencies = true;
                }
            }
        }
        
        // Reorder remaining features, respecting dependencies
        Map<String, Feature> resultFeatures = new LinkedHashMap<>();
        
        for (String featureId : initialFeatures.keySet())
        {
            _computeFeaturesDependencies(featureId, initialFeatures, resultFeatures, Collections.singletonList(featureId), errors);
        }
        
        return resultFeatures;
    }
    
    private boolean _processOutgoingDependenciesForFeature(
            Iterator<String> initialFeatureIterator, 
            Map<String, Feature> initialFeatures, 
            Map<String, InactivityStatus> inactiveFeatures, 
            String currentInitialFeatureId)
    {
        Feature currentInitialFeature = initialFeatures.get(currentInitialFeatureId);
        Collection<String> dependencies = _correctedDependencies.getCorrectedDependencies(currentInitialFeature);
        
        for (String dependency : dependencies)
        {
            if (!initialFeatures.containsKey(dependency))
            {
                _logger.debug("The feature '{}' depends on '{}' which is not present. It will be ignored.", currentInitialFeatureId, dependency);
                initialFeatureIterator.remove();
                inactiveFeatures.put(currentInitialFeatureId, new InactivityStatus(InactivityCause.DEPENDENCY, dependencies));
                // processDependencies = true;
                return true; // end iterate over dependencies (avoid a potential second it.remove() which will throw exception) and continue the while loop
            }
        }
        
        return false;
    }
    
    private void _computeFeaturesDependencies(
            String featureId, 
            Map<String, Feature> initialFeatures, 
            Map<String, Feature> resultFeatures, 
            List<String> involvedFeaturesInDependencyChain, 
            Collection<PluginIssue> errors)
    {
        Feature feature = Objects.requireNonNull(initialFeatures.get(featureId), String.format("Feature '%s' cannot be found", featureId));
        Collection<String> dependencies = _correctedDependencies.getCorrectedDependencies(feature);
        
        for (String dependency : dependencies)
        {
            if (involvedFeaturesInDependencyChain.contains(dependency))
            {
                String stringDependencyChain = Stream.concat(involvedFeaturesInDependencyChain.stream(), Stream.of(dependency))
                        .collect(Collectors.joining("->"));
                String message = "Circular dependency detected for feature: " + feature.getFeatureId()
                    + ". The dependency chain is: \n"
                    + stringDependencyChain;
                _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
                List<String> dependencyChain = ListUtils.union(involvedFeaturesInDependencyChain, Collections.singletonList(dependency));
                _computeFeaturesDependencies(dependency, initialFeatures, resultFeatures, dependencyChain, 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 = _correctedDependencies.getCorrectedDependencies(feature);
            
            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 = _correctedDependencies.getCorrectedDependencies(feature);
            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, InactivityStatus> 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, new InactivityStatus(InactivityCause.PASSIVE, null));
            }
        }
    }
    
    /**
     * 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)
    {
        return new LoadedFeaturesDump(this).fullDump(pluginInfo);
    }
    
    InactivityCause _getCause(Collection<IncomingDeactivation> deactivatedBy)
    {
        if (deactivatedBy.isEmpty())
        {
            throw new IllegalStateException("collection 'deactivatedBy' cannot be empty");
        }
        else if (deactivatedBy.size() == 1)
        {
            return deactivatedBy.iterator().next().getType().getInactivityCause();
        }
        else
        {
            return deactivatedBy.stream()
                    .map(IncomingDeactivation::getType)
                    .map(IncomingDeactivation.Type::getInactivityCause)
                    .filter(InactivityCause.OVERRIDDEN::equals) // if at least one is overridden, consider that this is the main cause of inactivity
                    .findAny()
                    .orElse(InactivityCause.DEACTIVATED);
            
        }
    }
}