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.registry.ArchetypeRegistry;

 import org.apache.maven.archetype.registry.io.xpp3.ArchetypeRegistryXpp3Reader;

 import org.apache.maven.archetype.registry.io.xpp3.ArchetypeRegistryXpp3Writer;

 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.codehaus.plexus.component.annotations.Component;

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

 import org.codehaus.plexus.logging.AbstractLogEnabled;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.ReaderFactory;

 import org.codehaus.plexus.util.StringUtils;

 import org.codehaus.plexus.util.WriterFactory;

 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

 import java.io.File;

 import java.io.IOException;

 import java.io.Reader;

 import java.io.Writer;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.List;

 @Component( role = ArchetypeRegistryManager.class )

 public class DefaultArchetypeRegistryManager

     extends AbstractLogEnabled

     implements ArchetypeRegistryManager

 {

     /**

      * Used to create ArtifactRepository objects given the urls of the remote repositories.

      */

     @Requirement

     private ArtifactRepositoryFactory artifactRepositoryFactory;

     /**

      * Determines whether the layout is legacy or not.

      */

     @Requirement

     private ArtifactRepositoryLayout defaultArtifactRepositoryLayout;

     public List<String> getFilteredExtensions( String archetypeFilteredExtentions, File archetypeRegistryFile )

         throws IOException

     {

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

         if ( StringUtils.isNotEmpty( archetypeFilteredExtentions ) )

         {

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

         }

         try

         {

             ArchetypeRegistry registry = readArchetypeRegistry( archetypeRegistryFile );

             filteredExtensions.addAll( registry.getFilteredExtensions() );

         }

         catch ( IOException e )

         {

             getLogger().warn( "Cannot read ~/.m2/archetype.xml" );

         }

         catch ( XmlPullParserException e )

         {

             getLogger().warn( "Cannot read ~/.m2/archetype.xml" );

         }

         if ( filteredExtensions.isEmpty() )

         {

             filteredExtensions.addAll( Constants.DEFAULT_FILTERED_EXTENSIONS );

         }

         return filteredExtensions;

     }

     public List<String> getLanguages( String archetypeLanguages, File archetypeRegistryFile )

         throws IOException

     {

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

         if ( StringUtils.isNotEmpty( archetypeLanguages ) )

         {

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

         }

         try

         {

             ArchetypeRegistry registry = readArchetypeRegistry( archetypeRegistryFile );

             languages.addAll( registry.getLanguages() );

         }

         catch ( IOException e )

         {

             getLogger().warn( "Can not read ~/.m2/archetype.xml" );

         }

         catch ( XmlPullParserException e )

         {

             getLogger().warn( "Can not read ~/.m2/archetype.xml" );

         }

         if ( languages.isEmpty() )

         {

             languages.addAll( Constants.DEFAULT_LANGUAGES );

         }

         return languages;

     }

     public ArchetypeRegistry readArchetypeRegistry( File archetypeRegistryFile )

         throws IOException, XmlPullParserException

     {

         if ( !archetypeRegistryFile.exists() )

         {

             return getDefaultArchetypeRegistry();

         }

         else

         {

             return readArchetypeRegistry( ReaderFactory.newXmlReader( archetypeRegistryFile ) );

         }

     }

     public ArchetypeRegistry readArchetypeRegistry( Reader reader )

         throws IOException, XmlPullParserException

     {

         ArchetypeRegistryXpp3Reader xpp3Reader = new ArchetypeRegistryXpp3Reader();

         try

         {

             return xpp3Reader.read( reader );

         }

         finally

         {

             IOUtil.close( reader );

         }

     }

     public void writeArchetypeRegistry( File archetypeRegistryFile, ArchetypeRegistry archetypeRegistry )

         throws IOException

     {

         ArchetypeRegistryXpp3Writer writer = new ArchetypeRegistryXpp3Writer();

         Writer out = WriterFactory.newXmlWriter( archetypeRegistryFile );

         try

         {

             writer.write( out, archetypeRegistry );

         }

         finally

         {

             IOUtil.close( out );

         }

     }

     /**

      * Code stealed from MavenArchetypeMojo

      * (org.apache.maven.plugins:maven-archetype-plugin:1.0-alpha4).

      */

     public 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 );

     }

     public ArchetypeRegistry getDefaultArchetypeRegistry()

     {

         ArchetypeRegistry registry = new ArchetypeRegistry();

         registry.getLanguages().addAll( Constants.DEFAULT_LANGUAGES );

         registry.getFilteredExtensions().addAll( Constants.DEFAULT_FILTERED_EXTENSIONS );

         return registry;

     }

 }