/*
 *  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.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.ListUtils;
import org.apache.commons.lang3.ArrayUtils;

import org.ametys.runtime.plugin.PluginsManager.InactivityCause;

/**
 * {@link FeatureActivator} which activates only passed included features and their dependencies.
 */
public final class IncludePolicyFeatureActivator extends AbstractFeatureActivator
{
    private static String[] __KERNEL_DEPENDENCIES_NEEDED = new String[]
    {
        "core/core.observation" // CocoonWrapper needs ObservationManager
    };
    
    private Collection<IncludedFeature> _includedFeatures;
    
    /**
     * Constructs a new feature activator with an 'include' policy
     * @param allPlugins all plugins
     * @param includedFeatures the features to include
     */
    public IncludePolicyFeatureActivator(Map<String, Plugin> allPlugins, Collection<IncludedFeature> includedFeatures)
    {
        super(allPlugins);
        _includedFeatures = includedFeatures;
    }

    @Override
    public PluginsInformation computeActiveFeatures(Map<String, String> componentsConfig, boolean safeMode)
    {
        _safeMode = safeMode;
        Map<String, Feature> initialFeatures = new HashMap<>();
        Map<String, ExtensionPointDefinition> extensionPoints = new HashMap<>();
        Map<String, InactivityCause> inactiveFeatures = new HashMap<>();
        Collection<PluginIssue> errors = new ArrayList<>();
        
        // Get actual plugin list, corresponding extension points and initial feature list
        Map<String, Plugin> plugins = computeActivePlugins(Collections.emptySet(), initialFeatures, inactiveFeatures, extensionPoints, errors);
        
        removeWrongPointReferences(initialFeatures, inactiveFeatures, extensionPoints, errors);

        // Process outgoing dependencies
        Map<String, Feature> activeFeatures = processOutgoingDependencies(initialFeatures, inactiveFeatures, errors);

        // Compute outgoing dependencies
        Map<String, Collection<String>> outgoingDependencies = computeOutgoingDependencies(activeFeatures);
        
        // Get included features, get its dependencies, remove unused features, deactivate features and finally remove dependencies becoming unused 
        List<String> includedFeatures = _getIncludedFeatures();
        Map<String, Collection<String>> incomingDeactivations = computeIncomingDeactivations(initialFeatures);
        List<String> dependencies = _getDependencies(includedFeatures, outgoingDependencies);
        List<String> includedFeaturesAndDependencies = ListUtils.union(includedFeatures, dependencies);
        _removeUnusedFeatures(activeFeatures, inactiveFeatures, includedFeaturesAndDependencies);
        Map<String, Collection<String>> featuresToDeactivate = _getFeaturesToDeactivate(incomingDeactivations, includedFeaturesAndDependencies);
        List<String> dependenciesNowUnused = _computeDependenciesNowUnused(featuresToDeactivate.keySet(), outgoingDependencies, includedFeatures, activeFeatures);
        _removeDeactivatedFeatures(activeFeatures, inactiveFeatures, featuresToDeactivate, dependenciesNowUnused);
        
        // Check uniqueness of extensions and components
        Map<String, Map<String, ExtensionDefinition>> extensions = computeExtensions(activeFeatures, errors);
        Map<String, ComponentDefinition> components = computeComponents(activeFeatures, componentsConfig, errors);
        
        return new PluginsInformation(plugins, activeFeatures, inactiveFeatures, extensionPoints, extensions, components, errors);
    }
    
    private List<String> _getIncludedFeatures()
    {
        return Stream.concat(
                   Stream.of(__KERNEL_DEPENDENCIES_NEEDED), 
                   _includedFeatures.stream()
                       .map(IncludedFeature::featureId)
               )
               .collect(Collectors.toList());
    }
    
    private List<String> _getDependencies(List<String> featuresToProcess, Map<String, Collection<String>> outgoingDependencies)
    {
        List<String> dependencies = new ArrayList<>();
        _fillRecursiveDependencies(featuresToProcess, outgoingDependencies, dependencies, false);
        return dependencies;
    }
    
    private void _fillRecursiveDependencies(Collection<String> featuresToProcess, Map<String, Collection<String>> outgoingDependencies, List<String> dependencyListToFill, boolean addFeaturesToProcess)
    {
        for (String featureToProcess : featuresToProcess)
        {
            if (addFeaturesToProcess)
            {
                dependencyListToFill.add(featureToProcess);
            }
            Collection<String> deps = outgoingDependencies.get(featureToProcess);
            if (deps != null)
            {
                _fillRecursiveDependencies(deps, outgoingDependencies, dependencyListToFill, true);
            }
        }
    }
    
    private void _removeUnusedFeatures(
            Map<String, Feature> activeFeatures, 
            Map<String, InactivityCause> inactiveFeatures, 
            Collection<String> featuresToKeep)
    {
        Set<String> ids = activeFeatures.keySet();
        Iterator<String> it = ids.iterator();
        while (it.hasNext())
        {
            String id = it.next();
            
            if (!featuresToKeep.contains(id))
            {
                _logger.debug("Remove unused feature '{}'", id);
                it.remove();
                if (!inactiveFeatures.containsKey(id))
                {
                    inactiveFeatures.put(id, InactivityCause.UNUSED);
                }
            }
        }
    }
    
    private Map<String, Collection<String>> _getFeaturesToDeactivate(Map<String, Collection<String>> incomingDeactivations, List<String> includedFeatures)
    {
        Map<String, Collection<String>> result = new HashMap<>();
        for (String id : includedFeatures)
        {
            if (incomingDeactivations.containsKey(id))
            {
                Collection<String> deactivatedBy = incomingDeactivations.get(id);
                if (deactivatedBy != null && CollectionUtils.containsAny(includedFeatures, deactivatedBy))
                {
                    result.put(id, CollectionUtils.intersection(includedFeatures, deactivatedBy));
                }
            }
        }
        return result;
    }
    
    private List<String> _computeDependenciesNowUnused(
            Collection<String> featuresToDeactivate, 
            Map<String, Collection<String>> outgoingDependencies,
            List<String> includedFeatures,
            Map<String, Feature> allFeatures)
    {
        List<String> dependenciesNowUnused = new ArrayList<>();
        
        Map<String, Collection<String>> incomingDependencies = computeIncomingDependencies(allFeatures);
        for (String featureToDeactivate : featuresToDeactivate)
        {
            Collection<String> dependencies = outgoingDependencies.get(featureToDeactivate);
            // Check it is only needed by the feature which will be deactivated
            for (String dependency : dependencies)
            {
                Collection<String> incomingDependency = incomingDependencies.get(dependency);
                if (incomingDependency.size() == 1 && incomingDependency.iterator().next().equals(featureToDeactivate) && !includedFeatures.contains(dependency))
                {
                    dependenciesNowUnused.add(dependency);
                }
            }
        }
        
        return dependenciesNowUnused;
    }
    
    private void _removeDeactivatedFeatures(Map<String, Feature> activeFeatures, Map<String, InactivityCause> inactiveFeatures, Map<String, Collection<String>> featuresToDeactivate, List<String> dependenciesNowUnused)
    {
        Iterator<String> it = activeFeatures.keySet().iterator();
        while (it.hasNext())
        {
            String id = it.next();
            if (featuresToDeactivate.containsKey(id))
            {
                Collection<String> deactivatedBy = featuresToDeactivate.get(id);
                _logger.debug("Remove feature {} deactivated by features {}", id, deactivatedBy);
                it.remove();
                inactiveFeatures.put(id, InactivityCause.DEACTIVATED);
            }
            else if (dependenciesNowUnused.contains(id))
            {
                _logger.debug("Remove unused dependency '{}'", id);
                it.remove();
                if (!inactiveFeatures.containsKey(id))
                {
                    inactiveFeatures.put(id, InactivityCause.UNUSED);
                }
            }
        }
    }
    
    @Override
    public String shortDump(PluginsInformation pluginInfo)
    {
        Collection<PluginIssue> errors = pluginInfo.getErrors();
        Map<String, InactivityCause> inactiveFeatures = pluginInfo.getInactiveFeatures();
        Map<String, Collection<String>> dependencies = computeIncomingDependencies(pluginInfo.getFeatures());
        StringBuilder sb = new StringBuilder();
        
        String separator = new String(new char[30]).replace('\0', '-');
        sb.append(separator).append("\n");
        
        List<String> pluginNames = _allPlugins.keySet()
                   .stream()
                   .sorted()
                   .collect(Collectors.toList());
        for (String pluginName : pluginNames)
        {
            Plugin plugin = _allPlugins.get(pluginName);
            _dumpPlugin(sb, plugin, dependencies, inactiveFeatures);
        }
        
        if (!errors.isEmpty())
        {
            sb.append("\nErrors :\n");
            errors.forEach(issue -> sb.append(issue.toString()).append('\n'));
        }
        
        sb.append(separator).append("\n");
        
        return sb.toString();
    }
    
    private void _dumpPlugin(StringBuilder sb, Plugin plugin, Map<String, Collection<String>> dependencies, Map<String, InactivityCause> inactiveFeatures)
    {
        String pluginName = plugin.getName();
        sb.append("Plugin ").append(pluginName);
        
        sb.append("\n\n");
        
        Map<String, Feature> activeFeatures = plugin.getFeatures();
        List<String> featureIds = activeFeatures.keySet()
                .stream()
                .sorted()
                .collect(Collectors.toList());
        for (String featureId : featureIds)
        {
            Feature feature = activeFeatures.get(featureId);
            _dumpFeature(sb, feature, dependencies, inactiveFeatures);
        }
        
        sb.append('\n');
    }
    
    private void _dumpFeature(StringBuilder sb, Feature feature, Map<String, Collection<String>> dependencies, Map<String, InactivityCause> inactiveFeatures)
    {
        String featureId = feature.getFeatureId();
        
        if (!inactiveFeatures.containsKey(featureId))
        {
            sb.append("  Feature ").append(featureId);
            List<String> dependenciesOfFeature = new ArrayList<>();
            if (dependencies.containsKey(featureId))
            {
                dependenciesOfFeature.addAll(dependencies.get(featureId));
            }
            Optional<IncludedFeature> includedFeature = _find(featureId);
            if (includedFeature.isPresent())
            {
                dependenciesOfFeature.add(0, "INCLUDED_FEATURE BY " + includedFeature.get().cause());
            }
            if (ArrayUtils.contains(__KERNEL_DEPENDENCIES_NEEDED, featureId))
            {
                dependenciesOfFeature.add(0, "KERNEL");
            }
            
            if (!dependenciesOfFeature.isEmpty())
            {
                sb.append("\n    --> brought by ").append(dependenciesOfFeature);
            }
            
            sb.append("\n\n");
        }
    }
    
    private Optional<IncludedFeature> _find(String featureId)
    {
        return _includedFeatures.stream()
                .filter(f -> featureId.equals(f.featureId()))
                .findFirst();
    }
    
    /**
     * A feature to include by {@link IncludePolicyFeatureActivator}
     */
    public static final class IncludedFeature
    {
        private String _featureId;
        private String _cause;
        
        private IncludedFeature(String featureId, String cause)
        {
            _featureId = featureId;
            _cause = cause;
        }
        
        /**
         * Creates an {@link IncludedFeature}
         * @param featureId The id of the feature
         * @param cause The cause of its inclusion
         * @return the feature to include
         */
        public static IncludedFeature of(String featureId, String cause)
        {
            return new IncludedFeature(featureId, cause);
        }
        
        /**
         * Gets the feature id
         * @return the feature id
         */
        public String featureId()
        {
            return _featureId;
        }
        
        /**
         * Gets the cause of the inclusion of the feture
         * @return the cause of the inclusion of the feture
         */
        public String cause()
        {
            return _cause;
        }
    }
}