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;
     }
 }