package org.apache.maven.archetype.ui.generation;

 /*

  * 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.commons.lang.StringUtils;

 import org.apache.maven.archetype.ArchetypeGenerationRequest;

 import org.apache.maven.archetype.ArchetypeManager;

 import org.apache.maven.archetype.catalog.Archetype;

 import org.apache.maven.archetype.exception.ArchetypeNotDefined;

 import org.apache.maven.archetype.exception.ArchetypeSelectionFailure;

 import org.apache.maven.archetype.exception.UnknownArchetype;

 import org.apache.maven.archetype.exception.UnknownGroup;

 import org.apache.maven.archetype.ui.ArchetypeDefinition;

 import org.codehaus.plexus.component.annotations.Component;

 import org.codehaus.plexus.component.annotations.Requirement;

 import org.codehaus.plexus.components.interactivity.PrompterException;

 import org.codehaus.plexus.logging.AbstractLogEnabled;

 import java.io.IOException;

 import java.util.HashMap;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 @Component( role = ArchetypeSelector.class )

 public class DefaultArchetypeSelector

     extends AbstractLogEnabled

     implements ArchetypeSelector

 {

     static final String DEFAULT_ARCHETYPE_GROUPID = "org.apache.maven.archetypes";

     static final String DEFAULT_ARCHETYPE_VERSION = "1.0";

     static final String DEFAULT_ARCHETYPE_ARTIFACTID = "maven-archetype-quickstart";

     @Requirement

     private ArchetypeSelectionQueryer archetypeSelectionQueryer;

     @Requirement

     private ArchetypeManager archetypeManager;

     public void selectArchetype( ArchetypeGenerationRequest request, Boolean interactiveMode, String catalogs )

         throws ArchetypeNotDefined, UnknownArchetype, UnknownGroup, IOException, PrompterException,

         ArchetypeSelectionFailure

     {

         ArchetypeDefinition definition = new ArchetypeDefinition( request );

         if ( definition.isDefined() && StringUtils.isNotEmpty( request.getArchetypeRepository() ) )

         {

             getLogger().info( "Archetype defined by properties" );

             return;

         }

         Map<String, List<Archetype>> archetypes = getArchetypesByCatalog( catalogs );

         if ( StringUtils.isNotBlank( request.getFilter() ) )

         {

             // applying some filtering depending on filter parameter

             archetypes = ArchetypeSelectorUtils.getFilteredArchetypesByCatalog( archetypes, request.getFilter() );

             if ( archetypes.isEmpty() )

             {

                 getLogger().info( "Your filter doesn't match any archetype, so try again with another value." );

                 return;

             }

         }

         if ( definition.isDefined() && StringUtils.isEmpty( request.getArchetypeRepository() ) )

         {

             Map.Entry<String, Archetype> found =

                 findArchetype( archetypes, request.getArchetypeGroupId(), request.getArchetypeArtifactId() );

             if ( found != null )

             {

                 String catalogKey = found.getKey();

                 Archetype archetype = found.getValue();

                 updateRepository( definition, archetype, catalogKey );

                 getLogger().info( "Archetype repository missing. Using the one from " + archetype + " found in catalog "

                                       + catalogKey );

             }

             else

             {

                 getLogger().warn(

                     "Archetype not found in any catalog. Falling back to central repository (http://repo1.maven.org/maven2)." );

                 getLogger().warn(

                     "Use -DarchetypeRepository=<your repository> if archetype's repository is elsewhere." );

                 definition.setRepository( "http://repo1.maven.org/maven2" );

             }

         }

         if ( !definition.isDefined() && definition.isPartiallyDefined() )

         {

             Map.Entry<String, Archetype> found =

                 findArchetype( archetypes, request.getArchetypeGroupId(), request.getArchetypeArtifactId() );

             if ( found != null )

             {

                 String catalogKey = found.getKey();

                 Archetype archetype = found.getValue();

                 updateDefinition( definition, archetype, catalogKey );

                 getLogger().info( "Archetype " + archetype + " found in catalog " + catalogKey );

             }

             else

             {

                 getLogger().warn( "Specified archetype not found." );

                 if ( interactiveMode.booleanValue() )

                 {

                     definition.setVersion( null );

                     definition.setGroupId( null );

                     definition.setArtifactId( null );

                 }

             }

         }

         // set the defaults - only group and version can be auto-defaulted

         if ( definition.getGroupId() == null )

         {

             definition.setGroupId( DEFAULT_ARCHETYPE_GROUPID );

         }

         if ( definition.getVersion() == null )

         {

             definition.setVersion( DEFAULT_ARCHETYPE_VERSION );

         }

         if ( !definition.isPartiallyDefined() )

         {

             // if artifact ID is set to its default, we still prompt to confirm

             if ( definition.getArtifactId() == null )

             {

                 getLogger().info(

                     "No archetype defined. Using " + DEFAULT_ARCHETYPE_ARTIFACTID + " (" + definition.getGroupId() + ":"

                         + DEFAULT_ARCHETYPE_ARTIFACTID + ":" + definition.getVersion() + ")" );

                 definition.setArtifactId( DEFAULT_ARCHETYPE_ARTIFACTID );

             }

             if ( interactiveMode.booleanValue() && ( archetypes.size() > 0 ) )

             {

                 Archetype selectedArchetype = archetypeSelectionQueryer.selectArchetype( archetypes, definition );

                 String catalogKey = getCatalogKey( archetypes, selectedArchetype );

                 updateDefinition( definition, selectedArchetype, catalogKey );

             }

             // Make sure the groupId and artifactId are valid, the version may just default to

             // the latest release.

             if ( !definition.isPartiallyDefined() )

             {

                 throw new ArchetypeSelectionFailure( "No valid archetypes could be found to choose." );

             }

         }

         // finally update the request with gathered information

         definition.updateRequest( request );

     }

     private Map<String, List<Archetype>> getArchetypesByCatalog( String catalogs )

     {

         if ( catalogs == null )

         {

             throw new NullPointerException( "catalogs cannot be null" );

         }

         Map<String, List<Archetype>> archetypes = new LinkedHashMap<String, List<Archetype>>();

         for ( String catalog : StringUtils.split( catalogs, "," ) )

         {

             if ( "internal".equalsIgnoreCase( catalog ) )

             {

                 archetypes.put( "internal", archetypeManager.getInternalCatalog().getArchetypes() );

             }

             else if ( "local".equalsIgnoreCase( catalog ) )

             {

                 archetypes.put( "local", archetypeManager.getDefaultLocalCatalog().getArchetypes() );

             }

             else if ( "remote".equalsIgnoreCase( catalog ) )

             {

                 List<Archetype> archetypesFromRemote = archetypeManager.getRemoteCatalog().getArchetypes();

                 if ( archetypesFromRemote.size() > 0 )

                 {

                     archetypes.put( "remote", archetypesFromRemote );

                 }

                 else

                 {

                     getLogger().warn( "No archetype found in remote catalog. Defaulting to internal catalog" );

                     archetypes.put( "internal", archetypeManager.getInternalCatalog().getArchetypes() );

                 }

             }

             else if ( catalog.startsWith( "file://" ) )

             {

                 String path = catalog.substring( 7 );

                 archetypes.put( catalog, archetypeManager.getLocalCatalog( path ).getArchetypes() );

             }

             else if ( catalog.startsWith( "http://" ) || catalog.startsWith( "https://" ) )

             {

                 archetypes.put( catalog, archetypeManager.getRemoteCatalog( catalog ).getArchetypes() );

             }

         }

         if ( archetypes.size() == 0 )

         {

             getLogger().info( "No catalog defined. Using internal catalog" );

             archetypes.put( "internal", archetypeManager.getInternalCatalog().getArchetypes() );

         }

         return archetypes;

     }

     private void updateRepository( ArchetypeDefinition definition, Archetype archetype, String catalogKey )

     {

         String repository = archetype.getRepository();

         if ( StringUtils.isNotEmpty( repository ) )

         {

             definition.setRepository( repository );

         }

         else if ( catalogKey.indexOf( ':' ) > 1 )

         {

             // file: or http:

             int lastIndex = catalogKey.lastIndexOf( '/' );

             String catalogBase = catalogKey.substring( 0, ( lastIndex > 7 ? lastIndex : catalogKey.length() ) );

             definition.setRepository( catalogBase );

         }

     }

     private void updateDefinition( ArchetypeDefinition definition, Archetype archetype, String catalogKey )

     {

         definition.setGroupId( archetype.getGroupId() );

         definition.setArtifactId( archetype.getArtifactId() );

         definition.setVersion( archetype.getVersion() );

         definition.setName( archetype.getArtifactId() );

         updateRepository( definition, archetype, catalogKey );

         definition.setGoals( StringUtils.join( archetype.getGoals().iterator(), "," ) );

     }

     public void setArchetypeSelectionQueryer( ArchetypeSelectionQueryer archetypeSelectionQueryer )

     {

         this.archetypeSelectionQueryer = archetypeSelectionQueryer;

     }

     private String getCatalogKey( Map<String, List<Archetype>> archetypes, Archetype selectedArchetype )

     {

         for ( Map.Entry<String, List<Archetype>> entry : archetypes.entrySet() )

         {

             List<Archetype> catalog = entry.getValue();

             if ( catalog.contains( selectedArchetype ) )

             {

                 return entry.getKey();

             }

         }

         return "";

     }

     private Map.Entry<String, Archetype> findArchetype( Map<String, List<Archetype>> archetypes, String groupId,

                                                         String artifactId )

     {

         Archetype example = new Archetype();

         example.setGroupId( groupId );

         example.setArtifactId( artifactId );

         for ( Map.Entry<String, List<Archetype>> entry : archetypes.entrySet() )

         {

             List<Archetype> catalog = entry.getValue();

             if ( catalog.contains( example ) )

             {

                 Archetype archetype = catalog.get( catalog.indexOf( example ) );

                 return newMapEntry( entry.getKey(), archetype );

             }

         }

         return null;

     }

     private static <K, V> Map.Entry<K, V> newMapEntry( K key, V value )

     {

         Map<K, V> map = new HashMap<K, V>( 1 );

         map.put( key, value );

         return map.entrySet().iterator().next();

     }

 }