package org.apache.maven.script.ant;

 /*

  * 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.artifact.Artifact;

 import org.apache.maven.artifact.DependencyResolutionRequiredException;

 import org.apache.maven.execution.MavenSession;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.ContextEnabled;

 import org.apache.maven.plugin.MojoExecution;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.PluginParameterExpressionEvaluator;

 import org.apache.maven.plugin.descriptor.PluginDescriptor;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.project.path.PathTranslator;

 import org.apache.tools.ant.Project;

 import org.apache.tools.ant.PropertyHelper;

 import org.apache.tools.ant.types.Path;

 import org.codehaus.plexus.archiver.ArchiverException;

 import org.codehaus.plexus.archiver.UnArchiver;

 import org.codehaus.plexus.archiver.zip.ZipUnArchiver;

 import org.codehaus.plexus.component.MapOrientedComponent;

 import org.codehaus.plexus.component.configurator.ComponentConfigurationException;

 import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator;

 import org.codehaus.plexus.component.factory.ant.AntComponentExecutionException;

 import org.codehaus.plexus.component.factory.ant.AntScriptInvoker;

 import org.codehaus.plexus.component.repository.ComponentRequirement;

 import org.codehaus.plexus.logging.LogEnabled;

 import org.codehaus.plexus.logging.Logger;

 import org.codehaus.plexus.util.StringUtils;

 import java.io.File;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 public class AntMojoWrapper

     extends AbstractMojo

     implements ContextEnabled, MapOrientedComponent, LogEnabled

 {

     private Map<String, Object> pluginContext;

     private final AntScriptInvoker scriptInvoker;

     private Project antProject;

     private MavenProject mavenProject;

     private MojoExecution mojoExecution;

     private MavenSession session;

     private PathTranslator pathTranslator;

     private Logger logger;

     private transient List<String> unconstructedParts = new ArrayList<String>();

     public AntMojoWrapper( AntScriptInvoker scriptInvoker )

     {

         this.scriptInvoker = scriptInvoker;

     }

     public void execute()

         throws MojoExecutionException

     {

         if ( antProject == null )

         {

             antProject = scriptInvoker.getProject();

         }

         Map<String, Object> allConfig = new HashMap<String, Object>();

         if ( pluginContext != null && !pluginContext.isEmpty() )

         {

             allConfig.putAll( pluginContext );

         }

         @SuppressWarnings( "unchecked" )

         Map<String, PathTranslator> refs = scriptInvoker.getReferences();

         if ( refs != null )

         {

             allConfig.putAll( refs );

             for ( Map.Entry<String, PathTranslator> entry : refs.entrySet() )

             {

                 if ( entry.getKey().startsWith( PathTranslator.class.getName() ) )

                 {

                     pathTranslator = entry.getValue();

                 }

             }

         }

         mavenProject = (MavenProject) allConfig.get( "project" );

         mojoExecution = (MojoExecution) allConfig.get( "mojoExecution" );

         session = (MavenSession) allConfig.get( "session" );

         unpackFileBasedResources();

         addClasspathReferences();

         if ( logger.isDebugEnabled() && !unconstructedParts.isEmpty() )

         {

             StringBuffer buffer = new StringBuffer();

             buffer.append( "The following standard Maven Ant-mojo support objects could not be created:\n\n" );

             for ( String part : unconstructedParts )

             {

                 buffer.append( "\n-  " ).append( part );

             }

             buffer.append( "\n\nMaven project, session, mojo-execution, or path-translation parameter information is " );

             buffer.append( "\nmissing from this mojo's plugin descriptor." );

             buffer.append( "\n\nPerhaps this Ant-based mojo depends on maven-script-ant < 2.1.0, " );

             buffer.append( "or used maven-plugin-tools-ant < 2.2 during release?\n\n" );

             logger.debug( buffer.toString() );

         }

         try

         {

             scriptInvoker.invoke();

         }

         catch ( AntComponentExecutionException e )

         {

             throw new MojoExecutionException( "Failed to execute: " + e.getMessage(), e );

         }

         unconstructedParts.clear();

     }

     public void setPluginContext( Map pluginContext )

     {

         this.pluginContext = pluginContext;

     }

     public Map getPluginContext()

     {

         return pluginContext;

     }

     public void addComponentRequirement( ComponentRequirement requirementDescriptor, Object requirementValue )

         throws ComponentConfigurationException

     {

         scriptInvoker.addComponentRequirement( requirementDescriptor, requirementValue );

     }

     public void setComponentConfiguration( Map componentConfiguration )

         throws ComponentConfigurationException

     {

         scriptInvoker.setComponentConfiguration( componentConfiguration );

         antProject = scriptInvoker.getProject();

     }

     private void unpackFileBasedResources()

         throws MojoExecutionException

     {

         if ( mojoExecution == null || mavenProject == null )

         {

             unconstructedParts.add( "Unpacked Ant build scripts (in Maven build directory)." );

             return;

         }

         // What we need to write out any resources in the plugin to the target directory of the

         // mavenProject using the Ant-based plugin:

         //

         // 1. Need a reference to the plugin JAR itself

         // 2. Need a reference to the ${basedir} of the mavenProject

         PluginDescriptor pluginDescriptor = mojoExecution.getMojoDescriptor().getPluginDescriptor();

         File pluginJar = pluginDescriptor.getPluginArtifact().getFile();

         String resourcesPath = pluginDescriptor.getArtifactId();

         File outputDirectory = new File( mavenProject.getBuild().getDirectory() );

         try

         {

             UnArchiver ua = new ZipUnArchiver( pluginJar );

             ua.extract( resourcesPath, outputDirectory );

         }

         catch ( ArchiverException e )

         {

             throw new MojoExecutionException( "Error extracting resources from your Ant-based plugin.", e );

         }

     }

     private void addClasspathReferences()

         throws MojoExecutionException

     {

         try

         {

             if ( mavenProject != null && session != null && pathTranslator != null )

             {

                 ExpressionEvaluator exprEvaluator =

                     new PluginParameterExpressionEvaluator( session, mojoExecution, pathTranslator, logger, mavenProject,

                                                             mavenProject.getProperties() );

                 PropertyHelper propertyHelper = PropertyHelper.getPropertyHelper( antProject );

                 propertyHelper.setNext( new AntPropertyHelper( exprEvaluator, mavenProject.getArtifacts(), getLog() ) );

             }

             else

             {

                 unconstructedParts.add( "Maven parameter expression evaluator for Ant properties." );

             }

             @SuppressWarnings( "unchecked" )

             Map<String, Object> references = scriptInvoker.getReferences();

             if ( mavenProject != null )

             {

                 // Compile classpath

                 Path p = new Path( antProject );

                 p.setPath( StringUtils.join( mavenProject.getCompileClasspathElements().iterator(), File.pathSeparator ) );

                 /* maven.dependency.classpath it's deprecated as it's equal to maven.compile.classpath */

                 references.put( "maven.dependency.classpath", p );

                 antProject.addReference( "maven.dependency.classpath", p );

                 references.put( "maven.compile.classpath", p );

                 antProject.addReference( "maven.compile.classpath", p );

                 // Runtime classpath

                 p = new Path( antProject );

                 p.setPath( StringUtils.join( mavenProject.getRuntimeClasspathElements().iterator(), File.pathSeparator ) );

                 references.put( "maven.runtime.classpath", p );

                 antProject.addReference( "maven.runtime.classpath", p );

                 // Test classpath

                 p = new Path( antProject );

                 p.setPath( StringUtils.join( mavenProject.getTestClasspathElements().iterator(), File.pathSeparator ) );

                 references.put( "maven.test.classpath", p );

                 antProject.addReference( "maven.test.classpath", p );

             }

             else

             {

                 unconstructedParts.add( "Maven standard project-based classpath references." );

             }

             if ( mojoExecution != null )

             {

                 // Plugin dependency classpath

                 Path p = getPathFromArtifacts( mojoExecution.getMojoDescriptor().getPluginDescriptor().getArtifacts(), antProject );

                 references.put( "maven.plugin.classpath", p );

                 antProject.addReference( "maven.plugin.classpath", p );

             }

             else

             {

                 unconstructedParts.add( "Maven standard plugin-based classpath references." );

             }

         }

         catch ( DependencyResolutionRequiredException e )

         {

             throw new MojoExecutionException( "Error creating classpath references for Ant-based plugin scripts.", e  );

         }

     }

     public Path getPathFromArtifacts( Collection<Artifact> artifacts, Project antProject )

         throws DependencyResolutionRequiredException

     {

         List<String> list = new ArrayList<String>( artifacts.size() );

         for ( Artifact a : artifacts )

         {

             File file = a.getFile();

             if ( file == null )

             {

                 throw new DependencyResolutionRequiredException( a );

             }

             list.add( file.getPath() );

         }

         Path p = new Path( antProject );

         p.setPath( StringUtils.join( list.iterator(), File.pathSeparator ) );

         return p;

     }

     public Project getAntProject()

     {

         return antProject;

     }

     public void setAntProject( Project antProject )

     {

         this.antProject = antProject;

     }

     public MavenProject getMavenProject()

     {

         return mavenProject;

     }

     public void setMavenProject( MavenProject mavenProject )

     {

         this.mavenProject = mavenProject;

     }

     public MojoExecution getMojoExecution()

     {

         return mojoExecution;

     }

     public void setMojoExecution( MojoExecution mojoExecution )

     {

         this.mojoExecution = mojoExecution;

     }

     public MavenSession getSession()

     {

         return session;

     }

     public void setSession( MavenSession session )

     {

         this.session = session;

     }

     public PathTranslator getPathTranslator()

     {

         return pathTranslator;

     }

     public void setPathTranslator( PathTranslator pathTranslator )

     {

         this.pathTranslator = pathTranslator;

     }

     public AntScriptInvoker getScriptInvoker()

     {

         return scriptInvoker;

     }

     public void enableLogging( Logger logger )

     {

         this.logger = logger;

     }

 }