package org.apache.maven.plugin.surefire.util;

 /*

  * 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 static org.apache.maven.plugin.surefire.util.ScannerUtil.convertJarFileResourceToJavaClassName;

 import static org.apache.maven.plugin.surefire.util.ScannerUtil.processIncludesExcludes;

 import java.io.File;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Enumeration;

 import java.util.List;

 import java.util.jar.JarEntry;

 import java.util.jar.JarFile;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.shared.utils.io.MatchPatterns;

 import org.apache.maven.surefire.util.DefaultScanResult;

 import javax.annotation.Nonnull;

 import javax.annotation.Nullable;

 /**

  * Scans dependencies looking for tests.

  *

  * @author Aslak Knutsen

  */

 public class DependencyScanner {

         private final List<File> dependenciesToScan;

         protected final List<String> includes;

         protected final @Nonnull List<String> excludes;

         protected final List<String> specificTests;

         public DependencyScanner(List<File> dependenciesToScan, List<String> includes, @Nonnull List<String> excludes, List<String> specificTests)

         {

                 this.dependenciesToScan = dependenciesToScan;

         this.includes = includes;

         this.excludes = excludes;

         this.specificTests = specificTests;

         }

         public DefaultScanResult scan() throws MojoExecutionException

         {

                 Matcher matcher = new Matcher(includes, excludes, specificTests);

                 List<String> found = new ArrayList<String>();

                 for(File artifact : dependenciesToScan)

                 {

                         try

                         {

                                 found.addAll(scanArtifact(artifact, matcher));

                         }

                         catch (IOException e)

                         {

                                 throw new MojoExecutionException("Could not scan dependency " + artifact.toString(), e);

                         }

                 }

                 return new DefaultScanResult(found);

         }

         private List<String> scanArtifact(File artifact, Matcher matcher) throws IOException

         {

                 List<String> found = new ArrayList<String>();

                 if(artifact != null) {

                         if(artifact.isFile()) {

                                 JarFile jar = null;

                                 try {

                                         jar = new JarFile(artifact);

                                         Enumeration<JarEntry> entries = jar.entries();

                                         while(entries.hasMoreElements())

                                         {

                                                 JarEntry entry = entries.nextElement();

                                                 if(matcher.shouldInclude(entry.getName()))

                                                 {

                                                         found.add(convertJarFileResourceToJavaClassName( entry.getName() ));

                                                 }

                                         }

                                 }

                                 finally

                                 {

                                         if(jar != null)

                                         {

                                                 jar.close();

                                         }

                                 }

                         }

                 }

                 return found;

         }

         public static List<File> filter(List<Artifact> artifacts, List<String> groupArtifactIds)

         {

                 List<File> matches = new ArrayList<File>();

                 if(groupArtifactIds == null || artifacts == null)

                 {

                         return matches;

                 }

                 for(Artifact artifact : artifacts)

                 {

                         for(String groups : groupArtifactIds)

                         {

                                 String[] groupArtifact = groups.split(":");

                                 if(groupArtifact.length != 2)

                                 {

                                         throw new IllegalArgumentException(

                                                         "dependencyToScan argument should be in format 'groupid:artifactid': " + groups);

                                 }

                                 if(

                                                 artifact.getGroupId().matches(groupArtifact[0]) &&

                                                 artifact.getArtifactId().matches(groupArtifact[1]))

                                 {

                                         matches.add(artifact.getFile());

                                 }

                         }

                 }

                 return matches;

         }

         private class Matcher {

                 private MatchPatterns includes;

                 private MatchPatterns excludes;

                 private SpecificFileFilter specificTestFilter;

                 public Matcher(@Nullable List<String> includes, @Nonnull List<String> excludes, @Nullable List<String> specificTests)

                 {

                         String[] specific = specificTests == null ? new String[0] : processIncludesExcludes( specificTests );

                         specificTestFilter = new SpecificFileFilter( specific );

                         if(includes != null && includes.size() > 0)

                         {

                                 this.includes = MatchPatterns.from(processIncludesExcludes(includes));

                         }

                         else

                         {

                                 this.includes = MatchPatterns.from("**");

                         }

                         this.excludes = MatchPatterns.from(processIncludesExcludes(excludes));

                 }

                 public boolean shouldInclude(String name)

                 {

                         if(!name.endsWith(".class"))

                         {

                                 return false;

                         }

                         boolean isIncluded = includes.matches(name, false);

                         boolean isExcluded = excludes.matches(name, false);

                         return isIncluded && !isExcluded && specificTestFilter.accept(name);

                 }

         }

 }