package org.apache.maven.archetype.common;
   
   /*
    * 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.archetype.common.util.ListScanner;
  import org.apache.maven.archetype.common.util.PathUtils;
  import org.apache.maven.archetype.metadata.FileSet;
  import org.codehaus.plexus.component.annotations.Component;
  import org.codehaus.plexus.logging.AbstractLogEnabled;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.StringUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  @Component( role = ArchetypeFilesResolver.class )
  public class DefaultArchetypeFilesResolver
      extends AbstractLogEnabled
      implements ArchetypeFilesResolver
  {
      public List<String> getFilesWithExtension( List<String> files, String extension )
      {
          ListScanner scanner = new ListScanner();
          scanner.setBasedir( "" );
  
          scanner.setIncludes( "**/*." + extension );
          scanner.setExcludes( "" );
  
          return scanner.scan( files );
      }
  
      public List<String> getFilteredFiles( List<String> files, String filtered )
      {
          ListScanner scanner = new ListScanner();
          scanner.setBasedir( "" );
  
          scanner.setIncludes( filtered );
          scanner.setExcludes( "" );
  
          List<String> result = scanner.scan( files );
          getLogger().debug( "Scanned " + result.size() + " filtered files in " + files.size() + " files" );
  
          return result;
      }
  
      public List<String> filterFiles( String moduleOffset, FileSet fileSet, List<String> archetypeResources )
      {
          ListScanner scanner = new ListScanner();
          scanner.setBasedir( ( StringUtils.isEmpty( moduleOffset ) ? "" : ( moduleOffset + File.separatorChar ) )
                                  + fileSet.getDirectory() );
          scanner.setIncludes( fileSet.getIncludes() );
          scanner.setExcludes( fileSet.getExcludes() );
          scanner.setCaseSensitive( true );
  
          return scanner.scan( archetypeResources );
      }
  
      public List<String> findOtherResources( int level, List<String> files, String languages )
      {
          ListScanner scanner = new ListScanner();
  
          scanner.setBasedir( "" );
  
          StringBuilder includes = new StringBuilder();
          for ( int i = 0; i < level; i++ )
          {
              includes.append( "*/" );
          }
  
          includes.append( "**" );
          scanner.setIncludes( includes.toString() );
          scanner.setExcludes( languages );
  
          List<String> result = scanner.scan( files );
          getLogger().debug(
              "Scanned " + result.size() + " other resources in " + files.size() + " files at level " + level );
  
         return result;
     }
 
     public List<String> findOtherResources( int level, List<String> files, List<String> sourcesFiles, String languages )
     {
         ListScanner scanner = new ListScanner();
 
         scanner.setBasedir( "" );
 
         Set<String> selectedDirectories = new HashSet<String>();
 
         List<String> includes = new ArrayList<String>();
 
         for ( String sourcesFile : sourcesFiles )
         {
             String directory = PathUtils.getDirectory( sourcesFile, level - 1 );
             if ( !selectedDirectories.contains( directory ) )
             {
                 includes.add( directory + "/**" );
             }
 
             selectedDirectories.add( directory );
         }
 
         scanner.setExcludes( languages );
 
         List<String> result = scanner.scan( files );
         getLogger().debug(
             "Scanned " + result.size() + " other resources in " + files.size() + " files at level " + level );
 
         return result;
     }
 
     public List<String> findOtherSources( int level, List<String> files, String languages )
     {
         ListScanner scanner = new ListScanner();
         scanner.setBasedir( "" );
 
         StringBuilder levelDirectory = new StringBuilder();
         for ( int i = 0; i < ( level - 1 ); i++ )
         {
             levelDirectory.append( "*/" );
         }
 
         StringBuilder includes = new StringBuilder();
         String[] languagesAsArray = StringUtils.split( languages );
         for ( int i = 0; i < languagesAsArray.length; i++ )
         {
             includes.append( levelDirectory ).append( languagesAsArray[i] );
         }
 
         scanner.setIncludes( includes.toString() );
 
         List<String> result = scanner.scan( files );
         getLogger().debug(
             "Scanned " + result.size() + " other sources in " + files.size() + " files at level " + level );
 
         return result;
     }
 
     public List<String> findResourcesMainFiles( List<String> files, String languages )
     {
         ListScanner scanner = new ListScanner();
         scanner.setBasedir( "src/main" );
 
         scanner.setIncludes( "**" );
         scanner.setExcludes( languages );
 
         List<String> result = scanner.scan( files );
         getLogger().debug( "Scanned " + result.size() + " resources in " + files.size() + " files" );
 
         return result;
     }
 
     public List<String> findResourcesTestFiles( List<String> files, String languages )
     {
         ListScanner scanner = new ListScanner();
         scanner.setBasedir( "src/test" );
 
         scanner.setIncludes( "**" );
         scanner.setExcludes( languages );
 
         List<String> result = scanner.scan( files );
         getLogger().debug( "Scanned " + result.size() + " test resources in " + files.size() + " files" );
 
         return result;
     }
 
     public List<String> findSiteFiles( List<String> files, String languages )
     {
         ListScanner scanner = new ListScanner();
         scanner.setBasedir( "src/site" );
 
         scanner.setIncludes( "**" );
         scanner.setExcludes( languages );
 
         List<String> result = scanner.scan( files );
         getLogger().debug( "Scanned " + result.size() + " site resources in " + files.size() + " files" );
 
         return result;
     }
 
     public List<String> findSourcesMainFiles( List<String> files, String languages )
     {
         ListScanner scanner = new ListScanner();
         scanner.setBasedir( "src/main" );
 
         scanner.setIncludes( languages );
 
         List<String> result = scanner.scan( files );
         getLogger().debug( "Scanned " + result.size() + " sources in " + files.size() + " files" );
 
         return result;
     }
 
     public List<String> findSourcesTestFiles( List<String> files, String languages )
     {
         ListScanner scanner = new ListScanner();
         scanner.setBasedir( "src/test" );
 
         scanner.setIncludes( languages );
 
         List<String> result = scanner.scan( files );
         getLogger().debug( "Scanned " + result.size() + " test sources in " + files.size() + " files" );
 
         return result;
     }
 
     public List<String> getPackagedFiles( List<String> files, String packageName )
     {
         List<String> packagedFiles = new ArrayList<String>();
         for ( String file : files )
         {
             if ( file.startsWith( packageName ) )
             {
                 packagedFiles.add( file.substring( packageName.length() + 1 ) );
             }
         }
         getLogger().debug( "Scanned " + packagedFiles.size() + " packaged files in " + files.size() + " files" );
         return packagedFiles;
     }
 
     public String resolvePackage( File basedir, List<String> languages )
         throws IOException
     {
         getLogger().debug( "Resolving package in " + basedir + " using languages " + languages );
 
         List<String> files = resolveFiles( basedir, languages );
 
         return resolvePackage( files );
     }
 
     public List<String> getUnpackagedFiles( List<String> files, String packageName )
     {
         List<String> unpackagedFiles = new ArrayList<String>();
         for ( String file : files )
         {
             if ( !file.startsWith( packageName ) )
             {
                 unpackagedFiles.add( file );
             }
         }
         getLogger().debug( "Scanned " + unpackagedFiles.size() + " unpackaged files in " + files.size() + " files" );
         return unpackagedFiles;
     }
 
     private String getCommonPackage( String packageName, String templatePackage )
     {
         String common = "";
 
         String difference = StringUtils.difference( packageName, templatePackage );
         if ( StringUtils.isNotEmpty( difference ) )
         {
             String temporaryCommon =
                 StringUtils.substring( templatePackage, 0, templatePackage.lastIndexOf( difference ) );
             if ( !difference.startsWith( "." ) )
             {
                 common = StringUtils.substring( temporaryCommon, 0, temporaryCommon.lastIndexOf( "." ) );
             }
             else
             {
                 common = temporaryCommon;
             }
         }
         else
         {
             common = packageName;
         }
 
         return common;
     }
 
     private List<String> resolveFiles( File basedir, List<String> languages )
         throws IOException
     {
         String[] languagesArray = languages.toArray( new String[languages.size()] );
         String[] languagesPathesArray = new String[languagesArray.length];
         for ( int i = 0; i < languagesArray.length; i++ )
         {
             languagesPathesArray[i] = "**/src/**/" + languagesArray[i] + "/**";
         }
 
         String excludes = "target";
         for ( String defaultExclude : Arrays.asList( ListScanner.DEFAULTEXCLUDES ) )
         {
             excludes += "," + defaultExclude + "/**";
         }
 
         @SuppressWarnings( "unchecked" ) List<File> absoluteFiles =
             FileUtils.getFiles( basedir, StringUtils.join( languagesPathesArray, "," ), excludes );
 
         getLogger().debug( "Found " + absoluteFiles.size() + " potential archetype files" );
 
         List<String> files = new ArrayList<String>( absoluteFiles.size() );
 
         for ( File file : absoluteFiles )
         {
             String filePath =
                 StringUtils.prechomp( file.getAbsolutePath(), basedir.getAbsolutePath() + File.separator );
 
             String minusSrc = StringUtils.prechomp( filePath, "src" + File.separator );
 
             for ( int i = 0; i < languagesArray.length; i++ )
             {
                 String language = languagesArray[i];
 
                 if ( StringUtils.countMatches( minusSrc, File.separator + language + File.separator ) > 0 )
                 {
                     String minusLanguage = StringUtils.prechomp( minusSrc, language + File.separator );
 
                     files.add( toUnixPath( minusLanguage ) );
                 }
             }
         }
 
         getLogger().debug( "Found " + files.size() + " archetype files for package resolution " );
 
         return files;
     }
 
     private String resolvePackage( List<String> files )
     {
         String packageName = null;
         for ( String minusLanguage : files )
         {
             String filePackage;
             if ( minusLanguage.indexOf( "/" ) >= 0 )
             {
                 filePackage =
                     StringUtils.replace( minusLanguage.substring( 0, minusLanguage.lastIndexOf( "/" ) ), "/", "." );
             }
             else
             {
                 filePackage = "";
             }
 
             if ( packageName == null )
             {
                 packageName = filePackage;
             }
             else
             {
                 packageName = getCommonPackage( packageName, filePackage );
             }
         }
 
         getLogger().debug( "Package resolved to " + packageName );
 
         return packageName;
     }
 
     private String toUnixPath( String path )
     {
         return path.replace( File.separatorChar, '/' );
     }
 }