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;
  
  /**
   * Creates an archetype project from the current project, with a <code>basic</code> integration-test.
   *
   * @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}" */
     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.
      *
      * @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;
 
     /** @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()
                 .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;
     }
 }