/*
 *  Copyright 2020 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.core.migration;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.core.ObservationConstants;
import org.ametys.core.migration.action.Action;
import org.ametys.core.migration.action.ActionExtensionPoint;
import org.ametys.core.migration.action.data.ActionData;
import org.ametys.core.migration.configuration.VersionConfiguration;
import org.ametys.core.migration.handler.VersionHandler;
import org.ametys.core.migration.handler.VersionHandlerExtensionPoint;
import org.ametys.core.migration.version.Version;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.runtime.plugin.ExtensionPoint;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Migration Extension Point that will list all migration needed by the current state of the application
 */
public class MigrationExtensionPoint extends AbstractLogEnabled implements ExtensionPoint<MigrationConfiguration>, ThreadSafe, Component, Serviceable
{
    /** Avalon Role */
    public static final String ROLE = MigrationExtensionPoint.class.getName();
    
    private Map<String, MigrationConfiguration> _configurations = new HashMap<>();
    
    private Map<String, String> _expectedVersionsForExtensions = new HashMap<>();

    private VersionHandlerExtensionPoint _versionHandlerEP;

    private ActionExtensionPoint _upgradeEP;
    private ActionExtensionPoint _initializationEP;

    private ObservationManager _observationManager;
    
    public void service(ServiceManager smanager) throws ServiceException
    {
        _versionHandlerEP = (VersionHandlerExtensionPoint) smanager.lookup(VersionHandlerExtensionPoint.ROLE);
        _upgradeEP = (ActionExtensionPoint) smanager.lookup(ActionExtensionPoint.ROLE_UPGRADE);
        _initializationEP = (ActionExtensionPoint) smanager.lookup(ActionExtensionPoint.ROLE_INITIALIZATION);
        
        if (smanager.hasService(ObservationManager.ROLE))
        {
            _observationManager = (ObservationManager) smanager.lookup(ObservationManager.ROLE);
        }
    }
    
    public void addExtension(String id, String pluginName, String featureName, Configuration configuration) throws ConfigurationException
    {
        _configurations.put(id, new MigrationConfiguration(id, pluginName, featureName, configuration));
    }

    public void initializeExtensions() throws Exception
    {
        // Nothing here
    }
    
    /**
     * All migrations are parsed and executed one per one in the right order
     */
    public void doMigration()
    {
        try
        {
            getLogger().info("Automatic migration start.");
            
            List<ActionData> allUpgradeActions = new ArrayList<>();
            Map<Version, List<ActionData>> allInitActions = new HashMap<>();
            boolean versionDeterminationFailed = false;
            Set<String> keySet = _configurations.keySet();
            for (String id : keySet)
            {
                MigrationConfiguration migrationConfiguration = _configurations.get(id);

                try
                {
                    String expectedVersion = _getHigherCurrentUpgradeVersionNumber(migrationConfiguration);
                    _expectedVersionsForExtensions.put(id, expectedVersion);
                }
                catch (ConfigurationException e)
                {
                    throw new MigrationException("Impossible to read the upgrade configuration for component '" + id + "'", e);
                }
                
                try
                {
                    Configuration configuration = migrationConfiguration.getConfiguration();
                    
                    List<Version> versions = new ArrayList<>();
                    for (Configuration versionConfiguration : configuration.getChild("versions").getChildren("version"))
                    {
                        try
                        {
                            VersionHandler versionHandler = _getVersionHandler(versionConfiguration);
                            VersionConfiguration versionConfigurationObject = versionHandler.getConfiguration(id, versionConfiguration);
                            versions.addAll(versionHandler.getCurrentVersions(id, versionConfigurationObject));
                        }
                        catch (NotMigrableInSafeModeException e)
                        {
                            getLogger().warn("The migration '{}' cannot be done in safe mode", id, e);
                        }
                        catch (MigrationException e)
                        {
                            versionDeterminationFailed = true;
                            getLogger().error("Error during version determination for component {}", id,  e);
                        }
                    }
                    
                    Map<Version, List<ActionData>> initActions = _getInitializationActions(versions, migrationConfiguration);
                    allInitActions.putAll(initActions);

                    List<ActionData> upgradeActions = _getUpgradeActions(versions, migrationConfiguration);
                    allUpgradeActions.addAll(upgradeActions);
                }
                catch (ConfigurationException | MigrationException e)
                {
                    throw new MigrationException("Exception occured in migration " + id, e);
                }
            }

            _applyInitializationActions(allInitActions);
            _applyUpgradeActions(allUpgradeActions);
            
            if (!versionDeterminationFailed)
            {
                _notifyEndOfMigration();
                
                // To free some memory space, not done on failing
                _configurations = null;
            }
            
            getLogger().info("Automatic migration finished.");
        }
        catch (MigrationException e)
        {
            getLogger().error("Error during the automatic migration", e);
        }
    }
    
    private VersionHandler _getVersionHandler(Configuration versionConfiguration) throws ConfigurationException
    {
        String versionHandlerType = versionConfiguration.getAttribute("type");
        
        VersionHandler extension = _versionHandlerEP.getExtension(versionHandlerType);
        if (extension == null)
        {
            throw new ConfigurationException("A migration requests a versionHandler with id '" + versionHandlerType + "', which does not exists, this migration can not be done.", versionConfiguration);
        }
        return extension;
    }

    /**
     * Notify with an {@link Event} the end of the migration.
     */
    protected void _notifyEndOfMigration()
    {
        if (_observationManager != null)
        {
            _observationManager.notify(new Event(ObservationConstants.EVENT_MIGRATION_ENDED, null, Map.of()));
        }
    }
    
    /**
     * Execute all needed upgrades
     * @param allInitializationActions list of needed upgrades
     * @throws MigrationException Something went wrong
     */
    protected void _applyInitializationActions(Map<Version, List<ActionData>> allInitializationActions) throws MigrationException
    {
        if (allInitializationActions.isEmpty())
        {
            getLogger().debug("No initialization to do");
        }
        else
        {
            for (Entry<Version, List<ActionData>> entry : allInitializationActions.entrySet())
            {
                Version version = entry.getKey();
                List<ActionData> actions = entry.getValue();
                
                for (ActionData initializationAction : actions)
                {
                    Action actionExtension = _initializationEP.getExtension(initializationAction.getType());
                    getLogger().info("Run initialization : " + initializationAction.toString());
                    actionExtension.doAction(initializationAction);
                }
                
                // The ID of the version had already be setted to the most recent action id
                _upgradeVersion(version);
            }
        }
    }
    /**
     * Execute all needed upgrades
     * @param allActions list of needed upgrades
     * @throws MigrationException Something went wrong
     */
    protected void _applyUpgradeActions(List<ActionData> allActions) throws MigrationException
    {
        allActions.sort(Comparator.comparing(ActionData::getVersionNumber));
        if (allActions.isEmpty())
        {
            getLogger().debug("No upgrade to do");
        }
        else
        {
            for (ActionData action : allActions)
            {
                Action upgradeExtension = _upgradeEP.getExtension(action.getType());
                getLogger().info("Run upgrade : " + action.toString());
                upgradeExtension.doAction(action);
                _upgradeVersion(action);
            }
        }
    }

    /**
     * When an upgrade (or an initialization) have been done, we write the new version
     * @param action upgrade/initialization executed
     * @throws MigrationException Something went wrong
     */
    protected void _upgradeVersion(ActionData action) throws MigrationException
    {
        Version newVersion = action.getVersion().copyFromActionData(action);
        _upgradeVersion(newVersion);
    }
    
    /**
     * When an upgrade (or an initialization) have been done, we write the new version
     * @param newVersion upgrade/initialization executed
     * @throws MigrationException Something went wrong
     */
    protected void _upgradeVersion(Version newVersion) throws MigrationException
    {
        getLogger().debug("Update version info vor version : " + newVersion.toString());
        String versionHandlerId = newVersion.getVersionHandlerId();
        VersionHandler versionHandler = _versionHandlerEP.getExtension(versionHandlerId);
        if (versionHandler == null)
        {
            throw new MigrationException("Version '" + newVersion.toString() + "' requires a versionHandler that does not exists: '" + versionHandlerId + "'.");
        }
        else
        {
            versionHandler.addVersion(newVersion);
        }
    }
    
    /**
     * Analyze the configuration to get a list of upgrades needed based on the current Versions
     * @param currentVersions list of current versions
     * @param migrationConfiguration configuration for this extension
     * @return a list of actions to work on, or null if an error occured
     * @throws MigrationException impossible to parse the configuration
     */
    protected List<ActionData> _getUpgradeActions(List<Version> currentVersions, MigrationConfiguration migrationConfiguration) throws MigrationException
    {
        String componentId = migrationConfiguration.getId();
        try
        {
            Configuration[] upgradeList = migrationConfiguration.getConfiguration().getChild("upgrades").getChildren("upgrade");
            
            List<ActionData> result = new ArrayList<>();
            
            for (Version version : currentVersions)
            {
                if (version == null)
                {
                    throw new MigrationException("The migration for '" + componentId + "' got a null Version.");
                }
                else if (version.getVersionNumber() != null)
                {
                    getLogger().debug("Check the upgrades needed for version: {}", version.toString());
                    String versionNumber = version.getVersionNumber();

                    String higherCurrentUpgradeVersionNumber = _getHigherCurrentUpgradeVersionNumber(migrationConfiguration);
                    if (higherCurrentUpgradeVersionNumber.compareTo(versionNumber) < 0)
                    {
                        getLogger().warn("There is a version stored more recent that any version available in conf for version: {}", version.toString());
                    }
                    
                    List<ActionData> thisVersionUpgrades = new ArrayList<>();
                    for (Configuration upgradeConf : upgradeList)
                    {
                        String upgradeVersionNumber = upgradeConf.getAttribute("versionNumber");
                        String type = upgradeConf.getAttribute("type");
                        String from = upgradeConf.getAttribute("from", null);
                        String comment = upgradeConf.getAttribute("comment", null);
                        
                        if (comment == null)
                        {
                            comment = "Automatic Upgrade.";
                        }
                        else
                        {
                            comment = "Automatic Upgrade: " + comment;
                        }
                        
                        Action actionExtension = _upgradeEP.getExtension(type);
                        
                        if (actionExtension == null)
                        {
                            throw new ConfigurationException("The type '" + type + "' does not exist.", upgradeConf);
                        }
                        
                        if (versionNumber.compareTo(upgradeVersionNumber) >= 0 // Obsolete migrations (migrating to older or current version) 
                            || (from != null && versionNumber.compareTo(from) > 0)) // Future migration migrating from an older version
                        {
                            continue;
                        }
                        else
                        {
                            ActionData upgradeData = actionExtension.generateActionData(upgradeVersionNumber, version, comment, from, type, migrationConfiguration.getPluginName(), upgradeConf);
                            thisVersionUpgrades.add(upgradeData);
                        }
                    }
                    
                    result.addAll(_removeDuplicatedActions(thisVersionUpgrades));
                }
            }
            
            return result;
        }
        catch (ConfigurationException e)
        {
            throw new MigrationException("Error while parsing configuration for component '" + componentId + "'", e);
        }
    }
    
    /**
     * Analyze the configuration to get a list of initializations needed based on the current Versions
     * @param currentVersions list of current versions
     * @param migrationConfiguration configuration for this extension
     * @return a list of actions to work on, or null if an error occured
     * @throws MigrationException impossible to parse the configuration
     */
    protected Map<Version, List<ActionData>> _getInitializationActions(List<Version> currentVersions, MigrationConfiguration migrationConfiguration) throws MigrationException
    {
        String componentId = migrationConfiguration.getId();
        Map<Version, List<ActionData>> result = new HashMap<>();
        try
        {
            Configuration[] initializations = migrationConfiguration.getConfiguration().getChild("initializations").getChildren("initialization");
            
            String versionComment = migrationConfiguration.getConfiguration().getChild("initializations").getAttribute("comment", null);
            
            if (versionComment == null)
            {
                versionComment = "Automatic Initialization.";
            }
            else
            {
                versionComment = "Automatic Initialization: " + versionComment;
            }
            
            for (Version version : currentVersions)
            {
                if (version == null)
                {
                    throw new MigrationException("The migration for '" + componentId + "' got a null Version.");
                }
                else if (version.getVersionNumber() == null)
                {
                    List<ActionData> thisVersionActions = new ArrayList<>();
                    getLogger().debug("No version number, this is an initialization: {}", version.toString());
                    
                    String higherCurrentUpgradeVersionNumber = _getHigherCurrentUpgradeVersionNumber(migrationConfiguration);
                    version.setVersionNumber(higherCurrentUpgradeVersionNumber);
                    version.setComment(versionComment);
                    
                    for (Configuration initialization : initializations)
                    {
                        String type = initialization.getAttribute("type");
                        String actionComment = null; // No comment will be used here, only the version will have a comment in an initialization
                        
                        Action actionExtension = _initializationEP.getExtension(type);
                        
                        if (actionExtension == null)
                        {
                            throw new ConfigurationException("The type '" + type + "' does not exist.", initialization);
                        }
                        ActionData initializationData = actionExtension.generateActionData(higherCurrentUpgradeVersionNumber, version, actionComment, null, type, migrationConfiguration.getPluginName(), initialization);
                        thisVersionActions.add(initializationData);
                    }

                    result.put(version, thisVersionActions);
                }
                
            }
            
            return result;
        }
        catch (ConfigurationException e)
        {
            throw new MigrationException("Error while parsing configuration for component '" + componentId + "'", e);
        }
    }
    
    
    /**
     * Returns the most recent version to apply (after an initialization)
     * @param migrationConfiguration Configuration of the extension
     * @return the id of the most current available version, or "0" if none available
     * @throws ConfigurationException Sompthing wrong while reading the configuration
     */
    protected String _getHigherCurrentUpgradeVersionNumber(MigrationConfiguration migrationConfiguration) throws ConfigurationException
    {
        Configuration[] upgradeList = migrationConfiguration.getConfiguration().getChild("upgrades").getChildren("upgrade");
        List<String> upgradeIds = new ArrayList<>();
        for (Configuration upgradeConf : upgradeList)
        {
            String id = upgradeConf.getAttribute("versionNumber");
            upgradeIds.add(id);
        }
        
        if (!upgradeIds.isEmpty())
        {
            upgradeIds.sort(String.CASE_INSENSITIVE_ORDER);
            return upgradeIds.get(upgradeIds.size() - 1);
        }
        else
        {
            return "0";
        }
    }
    
    /**
     * Parse the list of upgrade to remove the group-migration
     * @param actions list of upgrades to clean
     * @return a list with only needed upgrades.
     * @throws MigrationException list of actions incoherent
     */
    protected List<ActionData> _removeDuplicatedActions(List<ActionData> actions) throws MigrationException
    {
        // First, sort the upgrades by if to have the right order
        actions.sort(
            Comparator.comparing(ActionData::getVersionNumber)
                .thenComparing(
                    ActionData::getFrom,
                    Comparator.nullsFirst(Comparator.naturalOrder())
                )
        );
        
        // Create a list of pairs for each upgrade containing a "for" attribute to konw from which version to which version we should remove the lines
        List<Pair<String, String>> fromTo = actions.stream()
                                                    .filter(u -> StringUtils.isNotBlank(u.getFrom()))
                                                    .map(u -> Pair.of(u.getFrom(), u.getVersionNumber()))
                                                    .collect(Collectors.toList());

        _checkFromUpgrades(actions, fromTo);
        
        List<ActionData> result = actions;
        
        // Invert the order so we will start to apply the most recent one, it may override other lines with a From inside
        Collections.reverse(fromTo);
        // For each pair, remove the right versions
        for (Pair<String, String> pair : fromTo)
        {
            String from = pair.getLeft();
            String to = pair.getRight();
            
            result = result.stream()
                        .filter(
                            a -> a.getVersionNumber().compareTo(from) <= 0 
                            || (to.equals(a.getVersionNumber()) && from.equals(a.getFrom()))
                            || a.getVersionNumber().compareTo(to) > 0
                        )
                        .collect(Collectors.toList());
        }
        
        return result;
    }
    
    /**
     * Tests that in the list of fromTo, that each "fromTo" is linked to an action with the same id and without "from" 
     * @param actions list of actions
     * @param fromTo list of actions overriding multiple actions
     * @throws MigrationException there is an overriding version without a "simple" version with the same id
     */
    protected void _checkFromUpgrades(List<ActionData> actions, List<Pair<String, String>> fromTo) throws MigrationException
    {
        for (Pair<String, String> pair : fromTo)
        {
            String from = pair.getLeft();
            String to = pair.getRight();
            boolean anyMatch = actions.stream().anyMatch(a -> a.getFrom() == null && to.equals(a.getVersionNumber()));
            if (!anyMatch)
            {
                throw new MigrationException("The action from '" + from + "' to '" + to + "' does not contain a normal upgrade from '" + from + "'");
            }
        }
    }
    
    private Map<String, MigrationConfiguration> _getConfigurationsForReading()
    {
        if (_configurations == null)
        {
            throw new UnsupportedOperationException("Configurations have been emptied from the extension point, this method can't be used for now.");
        }
        return _configurations;
    }
    
    public boolean hasExtension(String id)
    {
        return _getConfigurationsForReading().containsKey(id);
    }

    public MigrationConfiguration getExtension(String id)
    {
        return _getConfigurationsForReading().get(id);
    }

    public Set<String> getExtensionsIds()
    {
        return _getConfigurationsForReading().keySet();
    }
    
    /**
     * Get the expected version for a component.
     * This is the latest upgrade number declared
     * @param id the id of the component
     * @return the expected version number for each version in this component
     * @throws MigrationException Component not found in the calculated map of expected versions
     */
    public String getExpectedVersionForComponent(String id) throws MigrationException
    {
        if (!_expectedVersionsForExtensions.containsKey(id))
        {
            throw new MigrationException("Component '" + id + "' is not found in the calculated expected versions");
        }
        return _expectedVersionsForExtensions.get(id);
    }
}