/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.maven.enforcer.rules;

import javax.inject.Inject;
import javax.inject.Named;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

import org.apache.maven.BuildFailureException;
import org.apache.maven.RepositoryUtils;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.enforcer.rule.api.EnforcerRuleError;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.apache.maven.enforcer.rules.utils.EnforcerRuleUtils;
import org.apache.maven.enforcer.rules.utils.ExpressionEvaluator;
import org.apache.maven.enforcer.rules.utils.PluginWrapper;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.lifecycle.DefaultLifecycles;
import org.apache.maven.lifecycle.Lifecycle;
import org.apache.maven.lifecycle.LifecycleExecutionException;
import org.apache.maven.lifecycle.mapping.LifecycleMapping;
import org.apache.maven.model.BuildBase;
import org.apache.maven.model.Model;
import org.apache.maven.model.ModelBase;
import org.apache.maven.model.Plugin;
import org.apache.maven.model.PluginConfiguration;
import org.apache.maven.model.PluginContainer;
import org.apache.maven.model.Profile;
import org.apache.maven.model.ReportPlugin;
import org.apache.maven.model.Reporting;
import org.apache.maven.plugin.InvalidPluginException;
import org.apache.maven.plugin.PluginManager;
import org.apache.maven.plugin.PluginManagerException;
import org.apache.maven.plugin.PluginNotFoundException;
import org.apache.maven.plugin.descriptor.PluginDescriptor;
import org.apache.maven.plugin.version.PluginVersionNotFoundException;
import org.apache.maven.plugin.version.PluginVersionResolutionException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.rtinfo.RuntimeInformation;
import org.apache.maven.settings.Settings;
import org.codehaus.plexus.PlexusContainer;
import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.codehaus.plexus.util.StringUtils;
import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.resolution.ArtifactRequest;
import org.eclipse.aether.resolution.ArtifactResolutionException;

import static java.util.Optional.ofNullable;

/**
 * This rule will enforce that all plugins specified in the poms have a version declared.
 *
 * @author <a href="mailto:brianf@apache.org">Brian Fox</a>
 */
@Named("requirePluginVersions")
public final class RequirePluginVersions extends AbstractStandardEnforcerRule {

    /**
     * Don't allow the LATEST identifier.
     */
    private boolean banLatest = true;

    /**
     * Don't allow the RELEASE identifier.
     */
    private boolean banRelease = true;

    /**
     * Don't allow snapshot plugins.
     */
    private boolean banSnapshots = true;

    /**
     * Don't allow timestamp snapshot plugins.
     */
    private boolean banTimestamps = true;

    /**
     * @since 3.0.0
     */
    private boolean banMavenDefaults = true;

    /**
     * The comma separated list of phases that should be used to find lifecycle plugin bindings. The default value is
     * "clean,deploy,site".
     */
    private String phases = "clean,deploy,site";

    /**
     * Additional plugins to enforce have versions. These are plugins that may not be in the poms but are used anyway,
     * like help, eclipse etc. <br>
     * The plugins should be specified in the form: <code>group:artifactId</code>.
     */
    private List<String> additionalPlugins;

    /**
     * Plugins to skip for version enforcement. The plugins should be specified in the form:
     * <code>group:artifactId</code>. NOTE: This is deprecated, use unCheckedPluginList instead.
     */
    private List<String> unCheckedPlugins;

    /**
     * Same as unCheckedPlugins but as a comma list to better support properties. Sample form:
     * <code>group:artifactId,group2:artifactId2</code>
     *
     * @since 1.0-beta-1
     */
    private String unCheckedPluginList;

    /** The phase to lifecycle map. */
    private Map<String, Lifecycle> phaseToLifecycleMap;

    /** The lifecycles. */
    private Collection<Lifecycle> lifecycles;

    /** The plugin manager. */
    private final PluginManager pluginManager;

    /** The factory. */
    private final ArtifactFactory factory;

    private final RepositorySystem repositorySystem;

    /** The session. */
    private final MavenSession session;

    /** The utils. */
    private final EnforcerRuleUtils utils;

    private final RuntimeInformation runtimeInformation;

    private final DefaultLifecycles defaultLifeCycles;

    private final MavenProject project;

    private final ExpressionEvaluator evaluator;

    private final PlexusContainer container;

    @Inject
    public RequirePluginVersions(
            PluginManager pluginManager,
            ArtifactFactory factory,
            RepositorySystem repositorySystem,
            MavenSession session,
            EnforcerRuleUtils utils,
            RuntimeInformation runtimeInformation,
            DefaultLifecycles defaultLifeCycles,
            MavenProject project,
            ExpressionEvaluator evaluator,
            PlexusContainer container) {
        this.pluginManager = Objects.requireNonNull(pluginManager);
        this.factory = Objects.requireNonNull(factory);
        this.repositorySystem = Objects.requireNonNull(repositorySystem);
        this.session = Objects.requireNonNull(session);
        this.utils = Objects.requireNonNull(utils);
        this.runtimeInformation = Objects.requireNonNull(runtimeInformation);
        this.defaultLifeCycles = Objects.requireNonNull(defaultLifeCycles);
        this.project = Objects.requireNonNull(project);
        this.evaluator = Objects.requireNonNull(evaluator);
        this.container = Objects.requireNonNull(container);
    }

    @Override
    public void execute() throws EnforcerRuleException {

        try {
            // get the various expressions out of the helper.

            lifecycles = defaultLifeCycles.getLifeCycles();

            // get all the plugins that are bound to the specified lifecycles
            Set<Plugin> allPlugins = getBoundPlugins(project, phases);

            // insert any additional plugins specified by the user.
            allPlugins = addAdditionalPlugins(allPlugins, additionalPlugins);
            allPlugins.addAll(getProfilePlugins(project));

            // pull out any we should skip
            allPlugins =
                    removeUncheckedPlugins(combineUncheckedPlugins(unCheckedPlugins, unCheckedPluginList), allPlugins);

            // there's nothing to do here
            if (allPlugins.isEmpty()) {
                getLog().info("No plugin bindings found.");
                return;
            } else {
                getLog().debug("All Plugins in use: " + allPlugins);
            }

            // get all the plugins that are mentioned in the pom (and parents)
            List<PluginWrapper> pluginWrappers = getAllPluginEntries(project);

            for (PluginWrapper pluginWrapper : pluginWrappers) {
                getLog().debug("pluginWrappers: " + pluginWrapper.getGroupId() + ":" + pluginWrapper.getArtifactId()
                        + ":" + pluginWrapper.getVersion() + " source: " + pluginWrapper.getSource());
            }
            // now look for the versions that aren't valid and add to a list.
            List<Plugin> failures = new ArrayList<>();

            for (Plugin plugin : allPlugins) {
                if (!hasValidVersionSpecified(plugin, pluginWrappers)) {
                    failures.add(plugin);
                }
            }

            // if anything was found, log it then append the optional message.
            if (!failures.isEmpty()) {
                handleMessagesToTheUser(project, failures);
            }
        } catch (PluginNotFoundException | LifecycleExecutionException e) {
            throw new EnforcerRuleException(e.getLocalizedMessage(), e);
        }
    }

    private void handleMessagesToTheUser(MavenProject project, List<Plugin> failures) throws EnforcerRuleException {
        StringBuilder newMsg = new StringBuilder();
        newMsg.append("Some plugins are missing valid versions or depend on Maven ");
        newMsg.append(runtimeInformation.getMavenVersion());
        newMsg.append(" defaults");
        handleBanMessages(newMsg);
        newMsg.append(System.lineSeparator());
        for (Plugin plugin : failures) {
            newMsg.append("   ");
            newMsg.append(plugin.getGroupId());
            newMsg.append(":");
            newMsg.append(plugin.getArtifactId());

            try {
                newMsg.append(". \tThe version currently in use is ");

                Plugin currentPlugin = findCurrentPlugin(plugin, project);

                if (currentPlugin == null) {
                    newMsg.append("unknown");
                } else {
                    newMsg.append(currentPlugin.getVersion());

                    if (PluginWrapper.isVersionFromDefaultLifecycleBindings(currentPlugin)
                            .orElse(false)) {
                        newMsg.append(" via default lifecycle bindings");
                    } else {
                        String msg = PluginWrapper.isVersionFromSuperpom(currentPlugin)
                                .filter(b -> b)
                                .map(t -> " via super POM")
                                // for Maven 3.6.0 or before (MNG-6593 / MNG-6600)
                                .orElse(" via super POM or default lifecycle bindings");
                        newMsg.append(msg);
                    }
                }
            } catch (Exception e) {
                // lots can go wrong here. Don't allow any issues trying to
                // determine the issue stop me
                getLog().debug("Exception while determining plugin Version " + e.getMessage());
                newMsg.append(". Unable to determine the plugin version.");
            }
            newMsg.append(System.lineSeparator());
        }
        String message = getMessage();
        if (message != null && !message.isEmpty()) {
            newMsg.append(message);
        }

        throw new EnforcerRuleException(newMsg.toString());
    }

    private void handleBanMessages(StringBuilder newMsg) {
        if (banLatest || banRelease || banSnapshots || banTimestamps) {
            List<String> banList = new ArrayList<>();
            if (banLatest) {
                banList.add("LATEST");
            }
            if (banRelease) {
                banList.add("RELEASE");
            }
            if (banSnapshots) {
                banList.add("SNAPSHOT");
                if (banTimestamps) {
                    banList.add("TIMESTAMP SNAPSHOT");
                }
            }
            if (!banList.isEmpty()) {
                newMsg.append(" (");
                newMsg.append(String.join(", ", banList));
                newMsg.append(" as plugin version are not allowed)");
            }
        }
    }

    /**
     * Remove the plugins that the user doesn't want to check.
     *
     * @param uncheckedPlugins
     * @param plugins
     * @return The plugins which have been removed.
     */
    Set<Plugin> removeUncheckedPlugins(Collection<String> uncheckedPlugins, Set<Plugin> plugins)
            throws EnforcerRuleError {
        if (uncheckedPlugins != null && !uncheckedPlugins.isEmpty()) {
            for (String pluginKey : uncheckedPlugins) {
                Plugin plugin = parsePluginString(pluginKey, "UncheckedPlugins");
                plugins.remove(plugin);
            }
        }
        return plugins;
    }

    /**
     * Combines the old Collection with the new comma separated list.
     *
     * @param uncheckedPlugins     a new collections
     * @param uncheckedPluginsList a list to merge
     * @return List of unchecked plugins.
     */
    public Collection<String> combineUncheckedPlugins(
            Collection<String> uncheckedPlugins, String uncheckedPluginsList) {
        // if the comma list is empty, then there's nothing to do here.
        if (uncheckedPluginsList != null && !uncheckedPluginsList.isEmpty()) {
            // make sure there is a collection to add to.
            if (uncheckedPlugins == null) {
                uncheckedPlugins = new HashSet<>();
            } else if (!uncheckedPlugins.isEmpty()) {
                getLog().warn("The parameter 'unCheckedPlugins' is deprecated. Use 'unCheckedPluginList' instead");
            }

            uncheckedPlugins.addAll(Arrays.asList(uncheckedPluginsList.split(",")));
        }
        return uncheckedPlugins;
    }

    /**
     * Add the additional plugins if they don't exist yet.
     *
     * @param existing   the existing
     * @param additional the additional
     * @return the sets the
     * @throws EnforcerRuleError the enforcer error
     */
    public Set<Plugin> addAdditionalPlugins(Set<Plugin> existing, List<String> additional) throws EnforcerRuleError {
        if (additional != null) {
            for (String pluginString : additional) {
                Plugin plugin = parsePluginString(pluginString, "AdditionalPlugins");

                if (existing == null) {
                    existing = new HashSet<>();
                    existing.add(plugin);
                } else if (!existing.contains(plugin)) {
                    existing.add(plugin);
                }
            }
        }
        return existing;
    }

    /**
     * Helper method to parse and inject a Plugin.
     *
     * @param pluginString a plugin description to parse
     * @param field        a source of pluginString
     * @return the prepared plugin
     */
    private Plugin parsePluginString(String pluginString, String field) throws EnforcerRuleError {
        if (pluginString != null) {
            String[] pluginStrings = pluginString.split(":");
            if (pluginStrings.length == 2) {
                Plugin plugin = new Plugin();
                plugin.setGroupId(StringUtils.strip(pluginStrings[0]));
                plugin.setArtifactId(StringUtils.strip(pluginStrings[1]));

                return plugin;
            } else {
                throw new EnforcerRuleError("Invalid " + field + " string: " + pluginString);
            }
        } else {
            throw new EnforcerRuleError("Invalid " + field + " string: " + pluginString);
        }
    }

    /**
     * Finds the plugins that are listed in active profiles.
     *
     * @param project the project
     * @return the profile plugins
     */
    public Set<Plugin> getProfilePlugins(MavenProject project) {
        Set<Plugin> result = new HashSet<>();
        List<Profile> profiles = project.getActiveProfiles();
        if (profiles != null && !profiles.isEmpty()) {
            for (Profile p : profiles) {
                BuildBase b = p.getBuild();
                if (b != null) {
                    List<Plugin> plugins = b.getPlugins();
                    if (plugins != null) {
                        result.addAll(plugins);
                    }
                }
            }
        }
        return result;
    }

    /**
     * Given a plugin, this will retrieve the matching plugin artifact from the model.
     *
     * @param plugin  plugin to lookup
     * @param project project to search
     * @return matching plugin, <code>null</code> if not found.
     */
    private Plugin findCurrentPlugin(Plugin plugin, MavenProject project) throws EnforcerRuleException {
        Plugin found = null;
        try {
            Model model = project.getModel();
            Map<String, Plugin> plugins = model.getBuild().getPluginsAsMap();
            found = plugins.get(plugin.getKey());
        } catch (NullPointerException e) {
            // nothing to do here
        }

        if (found == null) {
            Artifact artifact = factory.createPluginArtifact(
                    plugin.getGroupId(), plugin.getArtifactId(), VersionRange.createFromVersion("LATEST"));

            try {
                repositorySystem.resolveArtifact(
                        session.getRepositorySession(),
                        new ArtifactRequest(
                                RepositoryUtils.toArtifact(artifact),
                                session.getCurrentProject().getRemotePluginRepositories(),
                                "resolvePlugin"));
            } catch (ArtifactResolutionException e) {
                throw new EnforcerRuleException("Unable to resolve the plugin " + artifact.getArtifactId(), e);
            }
            plugin.setVersion(artifact.getVersion());

            found = plugin;
        }

        return found;
    }

    /**
     * Gets the plugins that are bound to the defined phases. This does not find plugins bound in the pom to a phase
     * later than the plugin is executing.
     *
     * @param project   the project
     * @param thePhases the phases
     * @return the bound plugins
     * @throws PluginNotFoundException     the plugin not found exception
     * @throws LifecycleExecutionException the lifecycle execution exception
     */
    private Set<Plugin> getBoundPlugins(MavenProject project, String thePhases)
            throws PluginNotFoundException, LifecycleExecutionException {

        Set<Plugin> allPlugins = new HashSet<>();

        // lookup the bindings for all the passed in phases
        String[] lifecyclePhases = thePhases.split(",");
        for (int i = 0; i < lifecyclePhases.length; i++) {
            String lifecyclePhase = lifecyclePhases[i];
            if (lifecyclePhase != null && !lifecyclePhase.isEmpty()) {
                try {
                    Lifecycle lifecycle = getLifecycleForPhase(lifecyclePhase);
                    getLog().debug("getBoundPlugins(): " + project.getId() + " " + lifecyclePhase + " "
                            + lifecycle.getId());
                    allPlugins.addAll(getAllPlugins(project, lifecycle));
                } catch (BuildFailureException e) {
                    // i'm going to swallow this because the
                    // user may have declared a phase that
                    // doesn't exist for every module.
                }
            }
        }
        return allPlugins;
    }

    /**
     * Checks for valid version specified. Checks to see if the version is specified for the plugin. Can optionally ban
     * "RELEASE" or "LATEST" even if specified.
     *
     * @param source         the source
     * @param pluginWrappers the plugins
     * @return true, if successful
     */
    public boolean hasValidVersionSpecified(Plugin source, List<PluginWrapper> pluginWrappers) {
        boolean found = false;
        boolean status = false;
        for (PluginWrapper plugin : pluginWrappers) {
            // find the matching plugin entry
            if (isMatchingPlugin(source, plugin)) {
                found = true;
                // found the entry. now see if the version is specified
                String version = plugin.getVersion();
                try {
                    version = (String) evaluator.evaluate(version);
                } catch (ExpressionEvaluationException e) {
                    return false;
                }

                if (isValidVersion(version)) {
                    getLog().debug("checking for notEmpty and notIsWhitespace(): " + version);
                    if (banRelease && version.equals("RELEASE")) {
                        return false;
                    }

                    if (banLatest && version.equals("LATEST")) {
                        return false;
                    }

                    if (banSnapshots && isSnapshot(version)) {
                        return false;
                    }
                    // the version was specified and not
                    // banned. It's ok. Keep looking through the list to make
                    // sure it's not using a banned version somewhere else.

                    status = true;

                    if (!banRelease && !banLatest && !banSnapshots) {
                        // no need to keep looking
                        break;
                    }
                }
            }
        }
        if (!found) {
            getLog().debug("plugin " + source.getGroupId() + ":" + source.getArtifactId() + " not found");
        }
        return status;
    }

    private boolean isValidVersion(String version) {
        return (version != null && !version.isEmpty()) && !StringUtils.isWhitespace(version);
    }

    private boolean isMatchingPlugin(Plugin source, PluginWrapper plugin) {
        return source.getArtifactId().equals(plugin.getArtifactId())
                && source.getGroupId().equals(plugin.getGroupId());
    }

    /**
     * Checks if is snapshot.
     *
     * @param baseVersion the base version
     * @return true, if is snapshot
     */
    private boolean isSnapshot(String baseVersion) {
        if (banTimestamps) {
            return Artifact.VERSION_FILE_PATTERN.matcher(baseVersion).matches()
                    || baseVersion.endsWith(Artifact.SNAPSHOT_VERSION);
        } else {
            return baseVersion.endsWith(Artifact.SNAPSHOT_VERSION);
        }
    }

    /*
     * Uses borrowed lifecycle code to get a list of all plugins bound to the lifecycle.
     */

    /**
     * Gets the all plugins.
     *
     * @param project   the project
     * @param lifecycle the lifecycle
     * @return the all plugins
     * @throws PluginNotFoundException     the plugin not found exception
     * @throws LifecycleExecutionException the lifecycle execution exception
     */
    private Set<Plugin> getAllPlugins(MavenProject project, Lifecycle lifecycle)
            throws PluginNotFoundException, LifecycleExecutionException {

        getLog().debug("RequirePluginVersions.getAllPlugins:");

        Set<Plugin> plugins = new HashSet<>();
        // first, bind those associated with the packaging
        Map<String, String> mappings = findMappingsForLifecycle(project, lifecycle);

        for (Map.Entry<String, String> entry : mappings.entrySet()) {
            getLog().debug("  lifecycleMapping = " + entry.getKey());
            String pluginsForLifecycle = (String) entry.getValue();
            getLog().debug("  plugins = " + pluginsForLifecycle);
            if (pluginsForLifecycle != null && !pluginsForLifecycle.isEmpty()) {
                String pluginList[] = pluginsForLifecycle.split(",");
                for (String plugin : pluginList) {
                    plugin = StringUtils.strip(plugin);
                    getLog().debug("    plugin = " + plugin);
                    String tokens[] = plugin.split(":");
                    getLog().debug("    GAV = " + Arrays.asList(tokens));

                    Plugin p = new Plugin();
                    p.setGroupId(tokens[0]);
                    p.setArtifactId(tokens[1]);
                    plugins.add(p);
                }
            }
        }

        plugins.addAll(project.getBuildPlugins());

        return plugins;
    }

    /*
     * NOTE: All the code following this point was scooped from the DefaultLifecycleExecutor. There must be a better way
     * but for now it should work.
     */

    /**
     * Gets the phase to lifecycle map.
     *
     * @return the phase to lifecycle map
     * @throws LifecycleExecutionException the lifecycle execution exception
     */
    public Map<String, Lifecycle> getPhaseToLifecycleMap() throws LifecycleExecutionException {
        if (phaseToLifecycleMap == null) {
            phaseToLifecycleMap = new HashMap<>();

            for (Lifecycle lifecycle : lifecycles) {
                List<String> phases = lifecycle.getPhases();
                for (String phase : phases) {
                    getLog().debug("getPhaseToLifecycleMap(): phase: " + phase);
                    if (phaseToLifecycleMap.containsKey(phase)) {
                        Lifecycle prevLifecycle = (Lifecycle) phaseToLifecycleMap.get(phase);
                        throw new LifecycleExecutionException("Phase '" + phase
                                + "' is defined in more than one lifecycle: '" + lifecycle.getId() + "' and '"
                                + prevLifecycle.getId() + "'");
                    } else {
                        phaseToLifecycleMap.put(phase, lifecycle);
                    }
                }
            }
        }
        return phaseToLifecycleMap;
    }

    /**
     * Gets the lifecycle for phase.
     *
     * @param phase the phase
     * @return the lifecycle for phase
     * @throws BuildFailureException       the build failure exception
     * @throws LifecycleExecutionException the lifecycle execution exception
     */
    private Lifecycle getLifecycleForPhase(String phase) throws BuildFailureException, LifecycleExecutionException {
        Lifecycle lifecycle = getPhaseToLifecycleMap().get(phase);

        if (lifecycle == null) {
            throw new BuildFailureException("Unable to find lifecycle for phase '" + phase + "'");
        }
        return lifecycle;
    }

    /**
     * Find mappings for lifecycle.
     *
     * @param project   the project
     * @param lifecycle the lifecycle
     * @return the map
     * @throws LifecycleExecutionException the lifecycle execution exception
     * @throws PluginNotFoundException     the plugin not found exception
     */
    private Map<String, String> findMappingsForLifecycle(MavenProject project, Lifecycle lifecycle)
            throws LifecycleExecutionException, PluginNotFoundException {
        String packaging = project.getPackaging();
        Map<String, String> mappings = null;

        LifecycleMapping m = (LifecycleMapping) findExtension(
                project, LifecycleMapping.ROLE, packaging, session.getSettings(), session.getLocalRepository());
        if (m != null) {
            mappings = m.getPhases(lifecycle.getId());
        }

        Map<String, String> defaultMappings = lifecycle.getDefaultPhases();

        if (mappings == null) {
            try {
                m = container.lookup(LifecycleMapping.class, packaging);
                mappings = m.getPhases(lifecycle.getId());
            } catch (ComponentLookupException e) {
                if (defaultMappings == null) {
                    throw new LifecycleExecutionException(
                            "Cannot find lifecycle mapping for packaging: \'" + packaging + "\'.", e);
                }
            }
        }

        if (mappings == null) {
            if (defaultMappings == null) {
                throw new LifecycleExecutionException(
                        "Cannot find lifecycle mapping for packaging: \'" + packaging + "\', and there is no default");
            } else {
                mappings = defaultMappings;
            }
        }

        return mappings;
    }

    /**
     * Find extension.
     *
     * @param project         the project
     * @param role            the role
     * @param roleHint        the role hint
     * @param settings        the settings
     * @param localRepository the local repository
     * @return the object
     * @throws LifecycleExecutionException the lifecycle execution exception
     * @throws PluginNotFoundException     the plugin not found exception
     */
    private Object findExtension(
            MavenProject project, String role, String roleHint, Settings settings, ArtifactRepository localRepository)
            throws LifecycleExecutionException, PluginNotFoundException {
        Object pluginComponent = null;

        List<Plugin> buildPlugins = project.getBuildPlugins();
        for (Plugin plugin : buildPlugins) {
            if (plugin.isExtensions()) {
                verifyPlugin(plugin, project, settings, localRepository);

                // TODO: if moved to the plugin manager we
                // already have the descriptor from above
                // and so do can lookup the container
                // directly
                try {
                    pluginComponent = pluginManager.getPluginComponent(plugin, role, roleHint);

                    if (pluginComponent != null) {
                        break;
                    }
                } catch (ComponentLookupException e) {
                    getLog().debug("Unable to find the lifecycle component in the extension " + e.getMessage());
                } catch (PluginManagerException e) {
                    throw new LifecycleExecutionException(
                            "Error getting extensions from the plugin '" + plugin.getKey() + "': " + e.getMessage(), e);
                }
            }
        }
        return pluginComponent;
    }

    /**
     * Verify plugin.
     *
     * @param plugin          the plugin
     * @param project         the project
     * @param settings        the settings
     * @param localRepository the local repository
     * @return the plugin descriptor
     * @throws LifecycleExecutionException the lifecycle execution exception
     * @throws PluginNotFoundException     the plugin not found exception
     */
    private PluginDescriptor verifyPlugin(
            Plugin plugin, MavenProject project, Settings settings, ArtifactRepository localRepository)
            throws LifecycleExecutionException, PluginNotFoundException {
        PluginDescriptor pluginDescriptor;
        try {
            pluginDescriptor = pluginManager.verifyPlugin(plugin, project, settings, localRepository);
        } catch (PluginManagerException e) {
            throw new LifecycleExecutionException(
                    "Internal error in the plugin manager getting plugin '" + plugin.getKey() + "': " + e.getMessage(),
                    e);
        } catch (PluginVersionResolutionException
                | InvalidVersionSpecificationException
                | InvalidPluginException
                | PluginVersionNotFoundException
                | org.apache.maven.artifact.resolver.ArtifactResolutionException
                | ArtifactNotFoundException e) {
            throw new LifecycleExecutionException(e.getMessage(), e);
        }
        return pluginDescriptor;
    }

    /**
     * Gets all plugin entries in build.plugins, build.pluginManagement.plugins, profile.build.plugins, reporting and
     * profile.reporting in this project and all parents
     *
     * @param project the project
     * @return the all plugin entries wrapped in a PluginWrapper Object
     */
    private List<PluginWrapper> getAllPluginEntries(MavenProject project) {
        List<PluginWrapper> plugins = new ArrayList<>();
        // now find all the plugin entries, either in
        // build.plugins or build.pluginManagement.plugins, profiles.plugins and reporting

        getPlugins(plugins, project.getModel());
        getReportingPlugins(plugins, project.getModel());
        getPluginManagementPlugins(plugins, project.getModel());
        addPluginsInProfiles(plugins, project.getModel());

        return plugins;
    }

    private void addPluginsInProfiles(List<PluginWrapper> plugins, Model model) {
        List<Profile> profiles = ofNullable(model).map(Model::getProfiles).orElseGet(Collections::emptyList);
        for (Profile profile : profiles) {
            getProfilePlugins(plugins, profile);
            getProfileReportingPlugins(plugins, profile);
            getProfilePluginManagementPlugins(plugins, profile);
        }
    }

    private void getProfilePluginManagementPlugins(List<PluginWrapper> plugins, Profile profile) {
        List<Plugin> modelPlugins = ofNullable(profile)
                .map(Profile::getBuild)
                .map(PluginConfiguration::getPluginManagement)
                .map(PluginContainer::getPlugins)
                .orElseGet(Collections::emptyList);
        plugins.addAll(PluginWrapper.addAll(utils.resolvePlugins(modelPlugins), banMavenDefaults));
    }

    private void getProfileReportingPlugins(List<PluginWrapper> plugins, Profile profile) {
        List<ReportPlugin> modelReportPlugins = ofNullable(profile)
                .map(ModelBase::getReporting)
                .map(Reporting::getPlugins)
                .orElseGet(Collections::emptyList);
        // add the reporting plugins
        plugins.addAll(PluginWrapper.addAll(utils.resolveReportPlugins(modelReportPlugins), banMavenDefaults));
    }

    private void getProfilePlugins(List<PluginWrapper> plugins, Profile profile) {
        List<Plugin> modelPlugins = ofNullable(profile)
                .map(Profile::getBuild)
                .map(PluginContainer::getPlugins)
                .orElseGet(Collections::emptyList);
        plugins.addAll(PluginWrapper.addAll(utils.resolvePlugins(modelPlugins), banMavenDefaults));
    }

    private void getPlugins(List<PluginWrapper> plugins, Model model) {
        List<Plugin> modelPlugins = ofNullable(model)
                .map(Model::getBuild)
                .map(PluginContainer::getPlugins)
                .orElseGet(Collections::emptyList);
        plugins.addAll(PluginWrapper.addAll(utils.resolvePlugins(modelPlugins), banMavenDefaults));
    }

    private void getPluginManagementPlugins(List<PluginWrapper> plugins, Model model) {
        List<Plugin> modelPlugins = ofNullable(model)
                .map(Model::getBuild)
                .map(PluginConfiguration::getPluginManagement)
                .map(PluginContainer::getPlugins)
                .orElseGet(Collections::emptyList);
        plugins.addAll(PluginWrapper.addAll(utils.resolvePlugins(modelPlugins), banMavenDefaults));
    }

    private void getReportingPlugins(List<PluginWrapper> plugins, Model model) {
        List<ReportPlugin> modelReportPlugins = ofNullable(model)
                .map(ModelBase::getReporting)
                .map(Reporting::getPlugins)
                .orElseGet(Collections::emptyList);
        // add the reporting plugins
        plugins.addAll(PluginWrapper.addAll(utils.resolveReportPlugins(modelReportPlugins), banMavenDefaults));
    }

    /**
     * Sets the ban latest.
     *
     * @param theBanLatest the banLatest to set
     */
    public void setBanLatest(boolean theBanLatest) {
        this.banLatest = theBanLatest;
    }

    /**
     * Sets the ban release.
     *
     * @param theBanRelease the banRelease to set
     */
    public void setBanRelease(boolean theBanRelease) {
        this.banRelease = theBanRelease;
    }

    /**
     * Checks if is ban snapshots.
     *
     * @return the banSnapshots
     */
    public boolean isBanSnapshots() {
        return this.banSnapshots;
    }

    /**
     * Sets the ban snapshots.
     *
     * @param theBanSnapshots the banSnapshots to set
     */
    public void setBanSnapshots(boolean theBanSnapshots) {
        this.banSnapshots = theBanSnapshots;
    }

    /**
     * Sets the ban timestamps.
     *
     * @param theBanTimestamps the banTimestamps to set
     */
    public void setBanTimestamps(boolean theBanTimestamps) {
        this.banTimestamps = theBanTimestamps;
    }

    @Override
    public String toString() {
        return String.format(
                "RequirePluginVersions[message=%s, banLatest=%b, banRelease=%b, banSnapshots=%b, banTimestamps=%b, phases=%s, additionalPlugins=%s, unCheckedPluginList=%s, unCheckedPlugins=%s]",
                getMessage(),
                banLatest,
                banRelease,
                banSnapshots,
                banTimestamps,
                phases,
                additionalPlugins,
                unCheckedPluginList,
                unCheckedPlugins);
    }
}