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.ArchetypeCreationRequest;

 import org.apache.maven.archetype.ArchetypeCreationResult;

 import org.apache.maven.archetype.ArchetypeManager;

 import org.apache.maven.archetype.common.Constants;

 import org.apache.maven.archetype.ui.creation.ArchetypeCreationConfigurator;

 import org.apache.maven.artifact.repository.ArtifactRepository;

 import org.apache.maven.execution.MavenSession;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.project.MavenProject;

 import org.codehaus.plexus.util.PropertyUtils;

 import org.codehaus.plexus.util.StringUtils;

 import java.io.File;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.List;

 import java.util.Properties;

 /**

  * <p>

  * Creates an archetype project from the current project.

  * </p>

  * <p>

  * This goal reads your source and resource files, the values of its parameters,

  * and properties you specify in a <code>.property</code> file, and uses them to

  * create a Maven archetype project using the maven-archetype packaging. 

  * If you build the resulting project, it will create the archetype. You can then

  * use this archetype to create new projects that resemble the original.  

  * </p>

  * <p>

  * The maven-archetype-plugin uses Velocity to expand template files, and this documentation

  * talks about 'Velocity Properties', which are values substituted into Velocity templates.

  * See <a href="http://velocity.apache.org/engine/devel/user-guide.html">The Velocity User's Guide</a>

  * for more information.

  * </p>

  * <p>

  * This goal modifies the text of the files of the current project to form the Velocity template files

  * that make up the archetype.

  * </p>

  * <dl>

  * <dt>GAV</dt><dd>The GAV values for the current project are replaced by properties: groupId, artifactId, and version.

  * The user chooses new values for these when generating a project from the archetype.</dd>

  * <dt>package</dt><dd>All the files under one specified Java (or cognate) package are relocated to a project 

  * that the user chooses when generating a project. References to the class name are replaced by a property reference. For

  * example, if the current project's sources are in the package <code>org.apache.saltedpeanuts</code>, then 

  * any example of the string <code>org.apache.saltedpeanuts</code> is replaced with the Velocity property

  * reference <code>${packageName}</code>. When the user generates a project, this is in turn replaced by

  * his or her choice of a package.  

  * </dd>

  * <dt>custom properties</dt><dd>You may identify additional strings that should be replaced by parameters. 

  * To add custom properties, you must use the <code>propertyFile</code> parameter to specify a property file.

  * See the documentation for <code>propertyFile</code> for the details.

  * </dl>

  * <p>

  * Note that you may need to edit the results of this goal. This goal has no way to exclude unwanted files,

  * or add copyright notices to the Velocity templates, or add more complex elements to the archetype metadata file.

  * </p>

  * <p>

  * This goal also generates a simple integration-test that exercises the generated archetype.

  * </p>

  *

  * @author rafale

  * @requiresProject true

  * @goal create-from-project

  * @execute phase="generate-sources"

  * @aggregator

  */

 public class CreateArchetypeFromProjectMojo

     extends AbstractMojo

 {

     /** @component */

     private ArchetypeCreationConfigurator configurator;

     /**

      * Enable the interactive mode to define the archetype from the project.

      *

      * @parameter expression="${interactive}" default-value="false"

      */

     private boolean interactive;

     /** @component */

     private ArchetypeManager manager;

     /**

      * File extensions which are checked for project's text files (vs binary files).

      *

      * @parameter expression="${archetype.filteredExtentions}"

      */

     private String archetypeFilteredExtentions;

     /**

      * Directory names which are checked for project's sources main package.

      *

      * @parameter expression="${archetype.languages}"

      */

     private String archetypeLanguages;

     /**

      * The location of the registry file.

      *

      * @parameter expression="${user.home}/.m2/archetype.xml"

      */

     private File archetypeRegistryFile;

     /**

      * Velocity templates encoding.

      *

      * @parameter default-value="UTF-8" expression="${archetype.encoding}"

      */

     private String defaultEncoding;

     /**

      * Create a partial archetype.

      *

      * @parameter expression="${archetype.partialArchetype}"

      */

     private boolean partialArchetype = false;

     /**

      * Create pom's velocity templates with CDATA preservation. This uses the <code>String.replaceAll()</code>

      * method and risks to have some overly replacement capabilities (beware of '1.0' value).

      *

      * @parameter expression="${archetype.preserveCData}"

      */

     private boolean preserveCData = false;

     /** @parameter expression="${localRepository}"

      * @readonly

      **/

     private ArtifactRepository localRepository;

     /**

      * POMs in archetype are created with their initial parent.

      * This property is ignored when preserveCData is true.

      *

      * @parameter expression="${archetype.keepParent}"

      */

     private boolean keepParent = true;

     /**

      * The Maven project to create an archetype from.

      *

      * @parameter expression="${project}"

      * @required

      * @readonly

      */

     private MavenProject project;

     /**

      * The property file that holds the plugin configuration. If this is provided, then

      * the plugin reads properties from here. The properties in here can be standard

      * properties listed below or custom properties for this archetype. The standard properties

      * are below. Several of them overlap parameters of this goal; it's better to just

      * set the parameter.

      * 

      *  <dl><dt>package</dt><dd>See the packageName parameter.</dd>

      *  <dt>archetype.languages</dt><dd>See the archetypeLanguages parameter.</dd>

      *  <dt>groupId</dt><dd>The default groupId of the generated project.</dd>

      *  <dt>artifactId</dt><dd>The default artifactId of the generated project.</dd> 

      *  <dt>version</dt><dd>The default version of the generated project.</dd>

      *  <dt>archetype.filteredExtensions</dt><dd>See the filteredExensions parameter.</dd>

      *  </dl>

      *  <strong>Custom Properties</strong>

      *  <p>

      *  Custom properties allow you to replace some constant values in the project's files

      *  with Velocity macro references. When a user generates a project from your archetype

      *  he or she gets the opportunity to replace the value from the source project. 

      *  </p>

      *  <p>

      *  Custom property names <strong>may not contain the '.' character</strong>.

      *  </p>

      *  <p>

      *  For example, if you include a line like the following in your property file:

      *  <pre>

      *          cxf-version=2.5.1-SNAPSHOT

      *  </pre>

      *  the plugin will search your files for the string <pre>2.5.1-SNAPSHOT</pre> and

      *  replace them with references to a velocity macro <pre>cxf-version</pre>. It will 

      *  then list <pre>cxf-version</pre> as a <pre>requiredProperty</pre> in the 

      *  archetype-metadata.xml, with <pre>2.5.1-SNAPSHOT</pre> as the default value.

      *  </p>

      *  

      *

      * @parameter expression="${archetype.properties}"

      */

     private File propertyFile;

     /**

      * The property telling which phase to call on the generated archetype.

      * Interesting values are: <code>package</code>, <code>integration-test</code>, <code>install</code> and <code>deploy</code>.

      *

      * @parameter expression="${archetype.postPhase}" default-value="package"

      */

     private String archetypePostPhase;

     /**

      * The directory where the archetype should be created.

      * 

      * @parameter expression="${project.build.directory}/generated-sources/archetype"

      */

     private File outputDirectory;

     /** @parameter expression="${testMode}" */

     private boolean testMode;

     /** 

      * The package name for Java source files to be incorporated in the archetype and 

      * and relocated to the package that the user selects.

      * 

      * @parameter expression="${packageName}" */

     private String packageName; //Find a better way to resolve the package!!! enforce usage of the configurator

     /**

      *  @parameter expression="${session}"

      *  @readonly

      */

     private MavenSession session;

     public void execute()

         throws MojoExecutionException, MojoFailureException

     {

         Properties executionProperties = session.getExecutionProperties();

         try

         {

             if ( propertyFile != null )

             {

                 propertyFile.getParentFile().mkdirs();

             }

             List<String> languages = getLanguages( archetypeLanguages, propertyFile );

             Properties properties =

                 configurator.configureArchetypeCreation( project, Boolean.valueOf( interactive ), executionProperties,

                                                          propertyFile, languages );

             List<String> filtereds = getFilteredExtensions( archetypeFilteredExtentions, propertyFile );

             ArchetypeCreationRequest request = new ArchetypeCreationRequest()

                 .setDefaultEncoding( defaultEncoding )

                 .setProject( project )

                 /* Used when in interactive mode */

                 .setProperties( properties )

                 .setLanguages( languages )

                 /* Should be refactored to use some ant patterns */

                 .setFiltereds( filtereds )

                 /* This should be correctly handled */

                 .setPreserveCData( preserveCData )

                 .setKeepParent( keepParent )

                 .setPartialArchetype( partialArchetype )

                 /* This should be used before there and use only languages and filtereds */

                 .setArchetypeRegistryFile( archetypeRegistryFile )

                 .setLocalRepository( localRepository )

                 /* this should be resolved and asked for user to verify */

                 .setPackageName( packageName )

                 .setPostPhase( archetypePostPhase )

                 .setOutputDirectory( outputDirectory );

             ArchetypeCreationResult result = manager.createArchetypeFromProject( request );

             if ( result.getCause() != null )

             {

                 throw new MojoFailureException( result.getCause(), result.getCause().getMessage(),

                                                 result.getCause().getMessage() );

             }

             getLog().info( "Archetype created in " + outputDirectory );

             if ( testMode )

             {

                 // Now here a properties file would be useful to write so that we could automate

                 // some functional tests where we string together an:

                 //

                 // archetype create from project -> deploy it into a test repo

                 // project create from archetype -> use the repository we deployed to archetype to

                 // generate

                 // test the output

                 //

                 // This of course would be strung together from the outside.

             }

         }

         catch ( MojoFailureException ex )

         {

             throw ex;

         }

         catch ( Exception ex )

         {

             throw new MojoFailureException( ex, ex.getMessage(), ex.getMessage() );

         }

     }

     private List<String> getFilteredExtensions( String archetypeFilteredExtentions, File propertyFile )

     {

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

         if ( StringUtils.isNotEmpty( archetypeFilteredExtentions ) )

         {

             filteredExtensions.addAll( Arrays.asList( StringUtils.split( archetypeFilteredExtentions, "," ) ) );

             getLog().debug( "Found in command line extensions = " + filteredExtensions );

         }

         if ( filteredExtensions.isEmpty() && propertyFile != null && propertyFile.exists() )

         {

             Properties properties = PropertyUtils.loadProperties( propertyFile );

             String extensions = properties.getProperty( Constants.ARCHETYPE_FILTERED_EXTENSIONS );

             if ( StringUtils.isNotEmpty( extensions ) )

             {

                 filteredExtensions.addAll( Arrays.asList( StringUtils.split( extensions, "," ) ) );

             }

             getLog().debug( "Found in propertyFile " + propertyFile.getName() + " extensions = " + filteredExtensions );

         }

         if ( filteredExtensions.isEmpty() )

         {

             filteredExtensions.addAll( Constants.DEFAULT_FILTERED_EXTENSIONS );

             getLog().debug( "Using default extensions = " + filteredExtensions );

         }

         return filteredExtensions;

     }

     private List<String> getLanguages( String archetypeLanguages, File propertyFile )

     {

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

         if ( StringUtils.isNotEmpty( archetypeLanguages ) )

         {

             resultingLanguages.addAll( Arrays.asList( StringUtils.split( archetypeLanguages, "," ) ) );

             getLog().debug( "Found in command line languages = " + resultingLanguages );

         }

         if ( resultingLanguages.isEmpty() && propertyFile != null && propertyFile.exists() )

         {

             Properties properties = PropertyUtils.loadProperties( propertyFile );

             String languages = properties.getProperty( Constants.ARCHETYPE_LANGUAGES );

             if ( StringUtils.isNotEmpty( languages ) )

             {

                 resultingLanguages.addAll( Arrays.asList( StringUtils.split( languages, "," ) ) );

             }

             getLog().debug( "Found in propertyFile " + propertyFile.getName() + " languages = " + resultingLanguages );

         }

         if ( resultingLanguages.isEmpty() )

         {

             resultingLanguages.addAll( Constants.DEFAULT_LANGUAGES );

             getLog().debug( "Using default languages = " + resultingLanguages );

         }

         return resultingLanguages;

     }

 }