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

import org.apache.commons.collections4.ListUtils;

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

/**
 * {@link FeatureActivator} which activates only passed included features and their dependencies.
 */
public final class IncludePolicyFeatureActivator extends AbstractFeatureActivator
{
    static String[] __KERNEL_DEPENDENCIES_NEEDED = new String[]
    {
        "core/core.observation", // CocoonWrapper needs ObservationManager
        "core/core.migration" // CocoonWrapper needs MigrationEngine
    };
    
    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, InactivityStatus> 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);

        Map<String, Collection<IncomingDeactivation>> incomingDeactivations = computeIncomingDeactivations(initialFeatures);
        
        // check consistency of given included features (it can lead to a paradox if one of them triggers by its dependencies the deactivation of another one)
        new IncludedFeatureConsistencyChecker(_includedFeatures, initialFeatures, incomingDeactivations).checkConsistency();
        
        _correctedDependencies = new CorrectedDependencies(initialFeatures, incomingDeactivations, _logger);
        
        // 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();
        List<String> dependencies = _getDependencies(includedFeatures, outgoingDependencies);
        List<String> includedFeaturesAndDependencies = ListUtils.union(includedFeatures, dependencies);
        _removeUnusedFeatures(activeFeatures, inactiveFeatures, includedFeaturesAndDependencies);
        Map<String, Collection<IncomingDeactivation>> 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, InactivityStatus> 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.info("Remove unused feature '{}'", id);
                it.remove();
                if (!inactiveFeatures.containsKey(id))
                {
                    inactiveFeatures.put(id, new InactivityStatus(InactivityCause.UNUSED, null));
                }
            }
        }
    }
    
    private Map<String, Collection<IncomingDeactivation>> _getFeaturesToDeactivate(Map<String, Collection<IncomingDeactivation>> incomingDeactivations, List<String> includedFeatures)
    {
        Map<String, Collection<IncomingDeactivation>> result = new HashMap<>();
        for (String id : includedFeatures)
        {
            if (incomingDeactivations.containsKey(id))
            {
                Collection<IncomingDeactivation> deactivatedBy = incomingDeactivations.get(id);
                if (IncomingDeactivation.containsAny(includedFeatures, deactivatedBy))
                {
                    result.put(id, IncomingDeactivation.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, InactivityStatus> inactiveFeatures, Map<String, Collection<IncomingDeactivation>> featuresToDeactivate, List<String> dependenciesNowUnused)
    {
        Iterator<String> it = activeFeatures.keySet().iterator();
        while (it.hasNext())
        {
            String id = it.next();
            if (featuresToDeactivate.containsKey(id))
            {
                Collection<IncomingDeactivation> deactivatedBy = featuresToDeactivate.get(id);
                _logger.debug("Remove feature {} deactivated by features {}", id, deactivatedBy);
                it.remove();
                InactivityCause cause = _getCause(deactivatedBy);
                Collection<String> sources = deactivatedBy.stream().map(IncomingDeactivation::getFeatureId).toList();
                inactiveFeatures.put(id, new InactivityStatus(cause, sources));
            }
            else if (dependenciesNowUnused.contains(id))
            {
                _logger.debug("Remove unused dependency '{}'", id);
                it.remove();
                if (!inactiveFeatures.containsKey(id))
                {
                    inactiveFeatures.put(id, new InactivityStatus(InactivityCause.UNUSED, null));
                }
            }
        }
    }
    
    @Override
    public String shortDump(PluginsInformation pluginInfo)
    {
        return new LoadedFeaturesDump(this).shortDump(pluginInfo, _includedFeatures);
    }
    
    /**
     * 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 feature
         * @return the cause of the inclusion of the feature
         */
        public String cause()
        {
            return _cause;
        }
        
        @Override
        public String toString()
        {
            return String.format("%s [included by %s]", _featureId, _cause);
        }
    }
}