package org.apache.maven.graph;
   
   /*
    * 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.
   */
  
  import org.apache.maven.MavenExecutionException;
  import org.apache.maven.execution.MavenExecutionRequest;
  import org.apache.maven.project.MavenProject;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Optional;
  import java.util.Set;
  
  /**
   * Utility class to extract {@link MavenProject} from the project graph during the execution phase based on optional or
   * required selectors.
   */
  public final class ProjectSelector
  {
      private static final Logger LOGGER = LoggerFactory.getLogger( ProjectSelector.class );
  
      public Set<MavenProject> getRequiredProjectsBySelectors( MavenExecutionRequest request, List<MavenProject> projects,
                                                               Set<String> projectSelectors )
              throws MavenExecutionException
      {
          Set<MavenProject> selectedProjects = new LinkedHashSet<>();
          File baseDirectory = getBaseDirectoryFromRequest( request );
          for ( String selector : projectSelectors )
          {
              Optional<MavenProject> optSelectedProject =
                      findOptionalProjectBySelector( projects, baseDirectory, selector );
              if ( !optSelectedProject.isPresent() )
              {
                  String message = "Could not find the selected project in the reactor: " + selector;
                  throw new MavenExecutionException( message, request.getPom() );
              }
  
              MavenProject selectedProject = optSelectedProject.get();
  
              selectedProjects.add( selectedProject );
              selectedProjects.addAll( getChildProjects( selectedProject, request ) );
          }
  
          return selectedProjects;
      }
  
      public Set<MavenProject> getOptionalProjectsBySelectors( MavenExecutionRequest request, List<MavenProject> projects,
                                                               Set<String> projectSelectors )
      {
          Set<MavenProject> resolvedOptionalProjects = new LinkedHashSet<>();
          Set<String> unresolvedOptionalSelectors = new HashSet<>();
          File baseDirectory = getBaseDirectoryFromRequest( request );
          for ( String selector : projectSelectors )
          {
              Optional<MavenProject> optSelectedProject =
                      findOptionalProjectBySelector( projects, baseDirectory, selector );
              if ( optSelectedProject.isPresent() )
              {
                  resolvedOptionalProjects.add( optSelectedProject.get() );
                  resolvedOptionalProjects.addAll( getChildProjects( optSelectedProject.get(), request ) );
              }
              else
              {
                  unresolvedOptionalSelectors.add( selector );
              }
          }
  
          if ( !unresolvedOptionalSelectors.isEmpty() )
          {
              LOGGER.info( "The requested optional projects {} do not exist.", unresolvedOptionalSelectors );
          }
  
          return resolvedOptionalProjects;
      }
  
      private List<MavenProject> getChildProjects( MavenProject parent, MavenExecutionRequest request )
      {
         final List<MavenProject> children = parent.getCollectedProjects();
         if ( children != null && request.isRecursive() )
         {
             return children;
         }
         else
         {
             return new ArrayList<>();
         }
     }
 
     private Optional<MavenProject> findOptionalProjectBySelector( List<MavenProject> projects, File reactorDirectory,
                                                                   String selector )
     {
         return projects.stream()
                 .filter( project -> isMatchingProject( project, selector, reactorDirectory ) )
                 .findFirst();
     }
 
     File getBaseDirectoryFromRequest( MavenExecutionRequest request )
     {
         return request.getBaseDirectory() != null ? new File( request.getBaseDirectory() ) : null;
     }
 
     boolean isMatchingProject( MavenProject project, String selector, File reactorDirectory )
     {
         // [groupId]:artifactId
         if ( selector.contains( ":" ) )
         {
             String id = ':' + project.getArtifactId();
 
             if ( id.equals( selector ) )
             {
                 return true;
             }
 
             id = project.getGroupId() + id;
 
             return id.equals( selector );
         }
 
         // relative path, e.g. "sub", "../sub" or "."
         else if ( reactorDirectory != null )
         {
             File selectedProject = new File( new File( reactorDirectory, selector ).toURI().normalize() );
 
             if ( selectedProject.isFile() )
             {
                 return selectedProject.equals( project.getFile() );
             }
             else if ( selectedProject.isDirectory() )
             {
                 return selectedProject.equals( project.getBasedir() );
             }
         }
 
         return false;
     }
 }