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.common.util.Format;

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

 import org.apache.maven.model.io.xpp3.MavenXpp3Reader;

 import org.apache.maven.model.io.xpp3.MavenXpp3Writer;

 import org.apache.maven.model.Model;

 import org.apache.maven.model.Parent;

 import org.apache.maven.model.Dependency;

 import org.apache.maven.model.Build;

 import org.apache.maven.model.Profile;

 import org.apache.maven.model.ModelBase;

 import org.apache.maven.model.Reporting;

 import org.apache.maven.model.ReportPlugin;

 import org.apache.maven.model.BuildBase;

 import org.apache.maven.model.Plugin;

 import org.codehaus.plexus.logging.AbstractLogEnabled;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.IOUtil;

 import org.codehaus.plexus.util.ReaderFactory;

 import org.codehaus.plexus.util.StringUtils;

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

 import org.codehaus.plexus.util.xml.Xpp3DomUtils;

 import org.codehaus.plexus.util.xml.Xpp3Dom;

 import org.dom4j.Document;

 import org.dom4j.DocumentException;

 import org.dom4j.Element;

 import org.dom4j.Node;

 import org.dom4j.io.SAXReader;

 import org.dom4j.io.XMLWriter;

 import org.jdom.JDOMException;

 import org.jdom.input.SAXBuilder;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.OutputStreamWriter;

 import java.io.Reader;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 /** @plexus.component */

 public class DefaultPomManager

     extends AbstractLogEnabled

     implements PomManager

 {

     public void addModule( File pom, String artifactId )

         throws IOException, XmlPullParserException, DocumentException, InvalidPackaging

     {

         boolean found = false;

         StringWriter writer = new StringWriter();

         Reader fileReader = null;

         try

         {

             fileReader = ReaderFactory.newXmlReader( pom );

             SAXReader reader = new SAXReader();

             Document document = reader.read( fileReader );

             Element project = document.getRootElement();

             String packaging = null;

             Element packagingElement = project.element( "packaging" );

             if ( packagingElement != null )

             {

                 packaging = packagingElement.getStringValue();

             }

             if ( !"pom".equals( packaging ) )

             {

                 throw new InvalidPackaging(

                     "Unable to add module to the current project as it is not of packaging type 'pom'"

                 );

             }

             Element modules = project.element( "modules" );

             if ( modules == null )

             {

                 modules = project.addText( "  " ).addElement( "modules" );

                 modules.setText( "\n  " );

                 project.addText( "\n" );

             }

             // TODO: change to while loop

             for ( @SuppressWarnings( "unchecked" )

             Iterator<Element> i = modules.elementIterator( "module" ); i.hasNext() && !found; )

             {

                 Element module = i.next();

                 if ( module.getText().equals( artifactId ) )

                 {

                     found = true;

                 }

             }

             if ( !found )

             {

                 Node lastTextNode = null;

                 for ( @SuppressWarnings( "unchecked" )

                 Iterator<Node> i = modules.nodeIterator(); i.hasNext(); )

                 {

                     Node node = i.next();

                     if ( node.getNodeType() == Node.ELEMENT_NODE )

                     {

                         lastTextNode = null;

                     }

                     else if ( node.getNodeType() == Node.TEXT_NODE )

                     {

                         lastTextNode = node;

                     }

                 }

                 if ( lastTextNode != null )

                 {

                     modules.remove( lastTextNode );

                 }

                 modules.addText( "\n    " );

                 modules.addElement( "module" ).setText( artifactId );

                 modules.addText( "\n  " );

                 XMLWriter xmlWriter = new XMLWriter( writer );

                 xmlWriter.write( document );

                 FileUtils.fileWrite( pom.getAbsolutePath(), writer.toString() );

             } // end if

         }

         finally

         {

             IOUtil.close( fileReader );

         }

     }

     public void addParent( File pom, File parentPom )

         throws IOException, XmlPullParserException

     {

         Model generatedModel = readPom( pom );

         if ( null != generatedModel.getParent() )

         {

             getLogger().info( "Parent element not overwritten in " + pom );

             return;

         }

         Model parentModel = readPom( parentPom );

         Parent parent = new Parent();

         parent.setGroupId( parentModel.getGroupId() );

         if ( parent.getGroupId() == null )

         {

             parent.setGroupId( parentModel.getParent().getGroupId() );

         }

         parent.setArtifactId( parentModel.getArtifactId() );

         parent.setVersion( parentModel.getVersion() );

         if ( parent.getVersion() == null )

         {

             parent.setVersion( parentModel.getParent().getVersion() );

         }

         generatedModel.setParent( parent );

         writePom( generatedModel, pom, pom );

     }

     public void mergePoms( File pom, File temporaryPom )

         throws IOException, XmlPullParserException

     {

         Model model = readPom( pom );

         Model generatedModel = readPom( temporaryPom );

         model.getProperties().putAll( generatedModel.getProperties() );

         mergeModelBase( model, generatedModel );

         mergeModelBuild( model, generatedModel );

         mergeProfiles( model, generatedModel );

         mergeReportPlugins( model, generatedModel );

 //

 //        // Potential merging

 //

 //        model.getModelEncoding ();

 //        model.getModelVersion ();

 //

 //        model.getGroupId ();

 //        model.getArtifactId ();

 //        model.getVersion ();

 //        model.getParent ();

 //

 //        model.getId ();

 //        model.getName ();

 //        model.getInceptionYear ();

 //        model.getDescription ();

 //        model.getUrl ();

 //        model.getLicenses ();

 //        model.getProperties ();

 //

 //        model.getOrganization ();

 //        model.getMailingLists ();

 //        model.getContributors ();

 //        model.getDevelopers ();

 //

 //        model.getScm ();

 //        model.getCiManagement ();

 //        model.getDistributionManagement ();

 //        model.getIssueManagement ();

 //

 //        model.getPackaging ();

 ////        model.getDependencies (); // done

 //        model.getDependencyManagement ();

 //        model.getPrerequisites ().getMaven ();

 //        model.getPrerequisites ().getModelEncoding ();

 //

 //        model.getProfiles ();

 //        model.getModules ();

 //        model.getRepositories ();

 //        model.getPluginRepositories ();

 //

 //        model.getBuild ().getDefaultGoal ();

 //        model.getBuild ().getFinalName ();

 //        model.getBuild ().getModelEncoding ();

 //        model.getBuild ().getFilters ();

 //        model.getBuild ().getDirectory ();

 //        model.getBuild ().getOutputDirectory ();

 //        model.getBuild ().getSourceDirectory ();

 //        model.getBuild ().getResources ();

 //        model.getBuild ().getScriptSourceDirectory ();

 //        model.getBuild ().getTestOutputDirectory ();

 //        model.getBuild ().getTestResources ();

 //        model.getBuild ().getTestSourceDirectory ();

 //        model.getBuild ().getPluginManagement ();

 //        model.getBuild ().getExtensions ();

 ////        model.getBuild ().getPluginsAsMap (); // done

 //

 //        model.getReporting ().getModelEncoding ();

 //        model.getReporting ().getOutputDirectory ();

 ////        model.getReporting ().getReportPluginsAsMap (); // done

 //

         writePom( model, pom, pom );

     }

     public Model readPom( final File pomFile )

         throws IOException, XmlPullParserException

     {

         Model model;

         Reader pomReader = null;

         try

         {

             pomReader = ReaderFactory.newXmlReader( pomFile );

             MavenXpp3Reader reader = new MavenXpp3Reader();

             model = reader.read( pomReader );

         }

         finally

         {

             IOUtil.close( pomReader );

         }

         return model;

     }

     public Model readPom( InputStream pomStream )

         throws IOException, XmlPullParserException

     {

         Reader pomReader = ReaderFactory.newXmlReader( pomStream );

         MavenXpp3Reader reader = new MavenXpp3Reader();

         return reader.read( pomReader );

     }

     public void writePom( final Model model, final File pomFile, final File initialPomFile )

         throws IOException

     {

         InputStream inputStream = null;

         Writer outputStreamWriter = null;

         String fileEncoding =

             StringUtils.isEmpty( model.getModelEncoding() ) ? "UTF-8" : model.getModelEncoding();

         try

         {

             inputStream = new FileInputStream( initialPomFile );

             SAXBuilder builder = new SAXBuilder();

             org.jdom.Document doc = builder.build( inputStream );

             inputStream.close();

             inputStream = null;

             // The cdata parts of the pom are not preserved from initial to target

             MavenJDOMWriter writer = new MavenJDOMWriter();

             outputStreamWriter =

                 new OutputStreamWriter( new FileOutputStream( pomFile ), fileEncoding );

             Format form = Format.getRawFormat().setEncoding( fileEncoding );

             writer.write( model, doc, outputStreamWriter, form );

         }

         catch ( JDOMException exc )

         {

             IOException ioe = new IOException( "Cannot parse the POM by JDOM while reading " + initialPomFile + ": "

                                                + exc.getMessage() );

             ioe.initCause( exc );

             throw ioe;

         }

         catch ( FileNotFoundException e )

         {

             getLogger().debug( "Creating pom file " + pomFile );

             Writer pomWriter = null;

             try

             {

                 pomWriter =

                     new OutputStreamWriter( new FileOutputStream( pomFile ), fileEncoding );

                 MavenXpp3Writer writer = new MavenXpp3Writer();

                 writer.write( pomWriter, model );

             }

             finally

             {

                 IOUtil.close( pomWriter );

             }

         }

         finally

         {

             IOUtil.close( inputStream );

             IOUtil.close( outputStreamWriter );

         }

     }

     private Map<String, Dependency> createDependencyMap( List<Dependency> dependencies )

     {

         Map<String, Dependency> dependencyMap = new HashMap<String, Dependency>();

         for ( Dependency dependency : dependencies )

         {

             dependencyMap.put( dependency.getManagementKey(), dependency );

         }

         return dependencyMap;

     }

     private void mergeModelBuild( Model model, Model generatedModel )

     {

         if ( generatedModel.getBuild() != null )

         {

             if ( model.getBuild() == null )

             {

                 model.setBuild( new Build() );

             }

             mergeBuildPlugins( model.getBuild(), generatedModel.getBuild() );

         }

     }

     private void mergeProfiles( Model model, Model generatedModel )

     {

         @SuppressWarnings( "unchecked" )

         List<Profile> generatedProfiles = generatedModel.getProfiles();

         if ( generatedProfiles != null && generatedProfiles.size() > 0 )

         {

             @SuppressWarnings( "unchecked" )

             List<Profile> modelProfiles = model.getProfiles();

             Map<String, Profile> modelProfileIdMap = new HashMap<String, Profile>();

             if ( modelProfiles == null )

             {

                 modelProfiles = new ArrayList<Profile>();

                 model.setProfiles( modelProfiles );

             }

             else if ( modelProfiles.size() > 0 )

             {

                 // add profile ids from the model for later lookups to the modelProfileIds set

                 for ( Profile modelProfile : modelProfiles )

                 {

                     modelProfileIdMap.put( modelProfile.getId(), modelProfile );

                 }

             }

             for ( Profile generatedProfile : generatedProfiles )

             {

                 String generatedProfileId = generatedProfile.getId();

                 if ( !modelProfileIdMap.containsKey( generatedProfileId ) )

                 {

                     model.addProfile( generatedProfile );

                 }

                 else

                 {

                     getLogger().warn( "Try to merge profiles with id " + generatedProfileId );

                     mergeModelBase( (Profile) modelProfileIdMap.get( generatedProfileId ), generatedProfile );

                     mergeProfileBuild( (Profile) modelProfileIdMap.get( generatedProfileId ), generatedProfile );

                 }

             }

         }

     }

     private void mergeProfileBuild( Profile modelProfile, Profile generatedProfile )

     {

         if ( generatedProfile.getBuild() != null )

         {

             if ( modelProfile.getBuild() == null )

             {

                 modelProfile.setBuild( new Build() );

             }

             mergeBuildPlugins( modelProfile.getBuild(), generatedProfile.getBuild() );

             // TODO: merge more than just plugins in the profile...

         }

     }

     private void mergeModelBase( ModelBase model, ModelBase generatedModel )

     {

         // ModelBase can be a Model or a Profile...

         @SuppressWarnings( "unchecked" )

         Map<String, Dependency> dependenciesByIds = createDependencyMap( model.getDependencies() );

         @SuppressWarnings( "unchecked" )

         Map<String, Dependency> generatedDependenciesByIds = createDependencyMap( generatedModel.getDependencies() );

         for ( String generatedDependencyId : generatedDependenciesByIds.keySet() )

         {

             if ( !dependenciesByIds.containsKey( generatedDependencyId ) )

             {

                 model.addDependency( (Dependency) generatedDependenciesByIds.get( generatedDependencyId ) );

             }

             else

             {

                 getLogger().warn( "Can not override property: " + generatedDependencyId );

             }

         // TODO: maybe warn, if a property key gets overridden?

         model.getProperties().putAll( generatedModel.getProperties() );

         // TODO: maybe merge more than just dependencies and properties...

         }

     }

     private void mergeReportPlugins( Model model, Model generatedModel )

     {

         if ( generatedModel.getReporting() != null )

         {

             if ( model.getReporting() == null )

             {

                 model.setReporting( new Reporting() );

             }

             @SuppressWarnings( "unchecked" )

             Map<String, ReportPlugin> reportPluginsByIds = model.getReporting().getReportPluginsAsMap();

             @SuppressWarnings( "unchecked" )

             Map<String, ReportPlugin> generatedReportPluginsByIds =

                 generatedModel.getReporting().getReportPluginsAsMap();

             for ( String generatedReportPluginsId : generatedReportPluginsByIds.keySet() )

             {

                 if ( !reportPluginsByIds.containsKey( generatedReportPluginsId ) )

                 {

                     model.getReporting().addPlugin( generatedReportPluginsByIds.get( generatedReportPluginsId ) );

                 }

                 else

                 {

                     getLogger().warn( "Can not override report: " + generatedReportPluginsId );

                 }

             }

         }

     }

     private void mergeBuildPlugins( BuildBase modelBuild, BuildBase generatedModelBuild )

     {

         @SuppressWarnings( "unchecked" )

         Map<String, Plugin> pluginsByIds = modelBuild.getPluginsAsMap();

         @SuppressWarnings( "unchecked" )

         List<Plugin> generatedPlugins = generatedModelBuild.getPlugins();

         for ( Plugin generatedPlugin : generatedPlugins )

         {

             String generatedPluginsId = generatedPlugin.getKey();

             if ( !pluginsByIds.containsKey( generatedPluginsId ) )

             {

                 modelBuild.addPlugin( generatedPlugin );

             }

             else

             {

                 getLogger().info( "Try to merge plugin configuration of plugins with id: " + generatedPluginsId );

                 Plugin modelPlugin = (Plugin) pluginsByIds.get( generatedPluginsId );

                 modelPlugin.setConfiguration( Xpp3DomUtils.mergeXpp3Dom( (Xpp3Dom) generatedPlugin.getConfiguration(),

                                                                          (Xpp3Dom) modelPlugin.getConfiguration() ) );

             }

         }

     }

 }