package org.apache.maven.archetype.mojos;
   
   /*
    * 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.ArchetypeGenerationRequest;
  import org.apache.maven.archetype.exception.UnknownArchetype;
  import org.apache.maven.archetype.old.OldArchetype;
  import org.apache.maven.archetype.old.ArchetypeDescriptorException;
  import org.apache.maven.archetype.old.ArchetypeNotFoundException;
  import org.apache.maven.archetype.old.ArchetypeTemplateProcessingException;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.artifact.repository.ArtifactRepositoryFactory;
  import org.apache.maven.artifact.repository.ArtifactRepositoryPolicy;
  import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.util.StringUtils;
  
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * The archetype creation goal looks for an archetype with a given groupId,
   * artifactId, and version and retrieves it from the remote repository. Once the
   * archetype is retrieved, it is then processed against a set of user parameters
   * to create a working Maven project.
   *
   * @description Creates a project from an archetype.
   * @requiresProject false
   * @goal create
   * @deprecated Please use the generate mojo instead.
   */
  public class MavenArchetypeMojo
      extends AbstractMojo
  {
      /**
       * Used to create the Archetype specified by the groupId, artifactId, and
       * version from the remote repository.
       *
       * @component
       */
      private OldArchetype archetype;
  
      /**
       * Used to create ArtifactRepository objects given the urls of the remote
       * repositories.
       *
       * @component
       */
      private ArtifactRepositoryFactory artifactRepositoryFactory;
  
      /**
       * Determines whether the layout is legacy or not.
       *
       * @component role="org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout" roleHint="default"
       */
      private ArtifactRepositoryLayout defaultArtifactRepositoryLayout;
  
  
      /**
       * Maven's local repository.
       *
       * @parameter expression="${localRepository}"
       * @required
       */
      private ArtifactRepository localRepository;
  
      /**
       * The Archetype Group Id to be used.
       *
       * @parameter expression="${archetypeGroupId}" default-value="org.apache.maven.archetypes"
       * @required
       */
      private String archetypeGroupId;
  
      /**
       * The Archetype Artifact Id to be used.
       *
       * @parameter expression="${archetypeArtifactId}" default-value="maven-archetype-quickstart"
       * @required
       */
     private String archetypeArtifactId;
 
     /**
      * The Archetype Version to be used.
      *
      * @parameter expression="${archetypeVersion}" default-value="RELEASE"
      * @required
      */
     private String archetypeVersion;
 
     /**
      * The Group Id of the project to be build.
      *
      * @parameter expression="${groupId}"
      */
     private String groupId;
 
     /**
      * The Artifact Id of the project to be build.
      *
      * @parameter expression="${artifactId}"
      */
     private String artifactId;
 
     /**
      * The Version of the project to be build.
      *
      * @parameter expression="${version}" default-value="1.0-SNAPSHOT"
      * @required
      */
     private String version;
 
     /**
      * The Package Name of the project to be build.
      *
      * @parameter expression="${packageName}" alias="package"
      */
     private String packageName;
 
     /**
      * The remote repositories available for discovering dependencies and extensions as indicated
      * by the POM.
      *
      * @parameter expression="${project.remoteArtifactRepositories}"
      * @required
      */
     private List<ArtifactRepository> pomRemoteRepositories;
 
     /**
      * Other remote repositories available for discovering dependencies and extensions.
      *
      * @parameter expression="${remoteRepositories}"
      */
     private String remoteRepositories;
 
     /**
      * The project to be created an archetype of.
      *
      * @parameter expression="${project}"
      */
     private MavenProject project;
 
     /**
      * @parameter expression="${basedir}" default-value="${user.dir}"
      */
     private String basedir;
 
     public void execute()
         throws MojoExecutionException
     {
         getLog().warn( "This goal is deprecated. Please use mvn archetype:generate instead" );
         // TODO: prompt for missing values
         // TODO: configurable license
 
         // ----------------------------------------------------------------------
         // archetypeGroupId
         // archetypeArtifactId
         // archetypeVersion
         //
         // localRepository
         // remoteRepository
         // parameters
         // ----------------------------------------------------------------------
 
         if ( project.getFile() != null && groupId == null )
         {
             groupId = project.getGroupId();
         }
 
         if ( packageName == null )
         {
             getLog().info( "Defaulting package to group ID: " + groupId );
 
             packageName = groupId;
         }
 
 
         List<ArtifactRepository> archetypeRemoteRepositories = new ArrayList<ArtifactRepository>( pomRemoteRepositories );
 
         if ( remoteRepositories != null )
         {
             getLog().info( "We are using command line specified remote repositories: " + remoteRepositories );
 
             archetypeRemoteRepositories = new ArrayList<ArtifactRepository>();
 
             String[] s = StringUtils.split( remoteRepositories, "," );
 
             for ( int i = 0; i < s.length; i++ )
             {
                 archetypeRemoteRepositories.add( createRepository( s[i], "id" + i ) );
             }
         }
 
         try
         {
             ArchetypeGenerationRequest request = new ArchetypeGenerationRequest()
                 .setPackage( packageName )
                 .setGroupId( groupId )
                 .setArtifactId( artifactId )
                 .setVersion( version )
                 .setArchetypeGroupId( archetypeGroupId )
                 .setArchetypeArtifactId( archetypeArtifactId )
                 .setArchetypeVersion( archetypeVersion )
                 .setLocalRepository( localRepository )
                 .setRemoteArtifactRepositories( archetypeRemoteRepositories )
                 .setOutputDirectory( basedir );
 
             archetype.createArchetype( request, createRepository( "http://repo1.maven.org/maven2", "central" ) );
         }
         catch ( UnknownArchetype e )
         {
             throw new MojoExecutionException( "Error creating from archetype", e );
         }
         catch ( ArchetypeNotFoundException e )
         {
             throw new MojoExecutionException( "Error creating from archetype", e );
         }
         catch ( ArchetypeDescriptorException e )
         {
             throw new MojoExecutionException( "Error creating from archetype", e );
         }
         catch ( ArchetypeTemplateProcessingException e )
         {
             throw new MojoExecutionException( "Error creating from archetype", e );
         }
     }
 
     //TODO: this should be put in John's artifact utils and used from there instead of being repeated here. Creating
     // artifact repositories is somewhat cumbersome atm.
     private ArtifactRepository createRepository( String url, String repositoryId )
     {
         // snapshots vs releases
         // offline = to turning the update policy off
 
         //TODO: we'll need to allow finer grained creation of repositories but this will do for now
 
         String updatePolicyFlag = ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS;
 
         String checksumPolicyFlag = ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN;
 
         ArtifactRepositoryPolicy snapshotsPolicy =
             new ArtifactRepositoryPolicy( true, updatePolicyFlag, checksumPolicyFlag );
 
         ArtifactRepositoryPolicy releasesPolicy =
             new ArtifactRepositoryPolicy( true, updatePolicyFlag, checksumPolicyFlag );
 
         return artifactRepositoryFactory.createArtifactRepository( repositoryId, url, defaultArtifactRepositoryLayout,
                                                                    snapshotsPolicy, releasesPolicy );
     }
 }