package org.codehaus.mojo.javascript;
   
   /*
    * Derivative Work
    * Copyright 2010 SOFTEC sa. All rights reserved.
    *
    * Original Work
    * Copyright 2001-2005 The Apache Software Foundation.
    *
   * Licensed 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.commons.lang.StringUtils;
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.factory.ArtifactFactory;
  import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
  import org.apache.maven.artifact.resolver.ArtifactResolver;
  import org.apache.maven.artifact.versioning.VersionRange;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.mojo.javascript.compress.CompressionException;
  import org.codehaus.mojo.javascript.compress.IsolatedClassLoader;
  import org.codehaus.mojo.javascript.compress.JSCompressor;
  import org.codehaus.mojo.javascript.compress.JSMinCompressor;
  import org.codehaus.plexus.util.DirectoryScanner;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.IOUtil;
  
  import java.io.*;
  import java.text.NumberFormat;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  /**
   * Abstact mojo for compressing JavaScripts.
   * 
   * @author <a href="mailto:nicolas@apache.org">nicolas De Loof</a>
   */
  public abstract class AbstractCompressMojo
      extends AbstractMojo
  {
  
      /**
       * Resolves the artifacts and dependencies.
       * 
       * @component
       */
      private ArtifactResolver artifactResolver;
  
      /**
       * Create Artifact references
       * 
       * @component
       */
      private ArtifactFactory artifactFactory;
  
      /**
       * The local repository
       * 
       * @parameter expression="${localRepository}"
       * @required
       */
      private ArtifactRepository localRepository;
  
      /**
       * For retrieval of artifact's metadata.
       * 
       * @component
       */
      private ArtifactMetadataSource metadataSource;
  
      /**
       * The remote repositories declared in the pom.
       * 
       * @parameter expression="${project.pluginArtifactRepositories}"
       */
      private List remoteRepositories;
  
      /**
       *
       */
      private static final NumberFormat INTEGER = NumberFormat.getIntegerInstance();
  
      private static final String HR = StringUtils.rightPad( "", 78, "-" );
 
     /**
      * The maven project we are working on.
      * 
      * @parameter default-value="${project}"
      * @required
      * @readonly
      */
     MavenProject project;
 
     /**
      * The available compressors
      */
     private Map compressors = new HashMap();
     {
         compressors.put( "jsmin", new JSMinCompressor() );
     }
 
     /**
      * Optimization level, from 0 to 9
      * 
      * @parameter default-value="9"
      */
     private int optimizationLevel;
 
     /**
      * JS Language version (130 for JS 1.3)
      * 
      * @parameter default-value="130"
      */
     private int languageVersion;
 
     /**
      * The compressor to used. Either "shrinksafe", "yahooui" or "jsmin" for default compressor, 
 	 * or a custom one provided as an artifact in repo org.codehaus.mojo.javascript:[xxx]-compressor.
      * 
      * @parameter default-value="jsmin"
      */
     private String compressor;
 
     /**
      * Don't display compression stats
      * 
      * @parameter
      */
     private boolean skipStats;
 
     private static final String[] DEFAULT_INCLUDES = new String[] { "**/*.js" };
 
     /**
      * Inclusion patterns
      * 
      * @parameter
      */
     private String[] includes;
 
     /**
      * Exclusion patterns
      * 
      * @parameter
      */
     private String[] excludes;
 
     /**
      * A list of special token to recognize lines to be removed from scripts (debugging
      * code).
      * 
      * @parameter
      */
     private String[] strips;
 
     /**
      * A special token to recognize lines to be removed from scripts (debugging
      * code).
      *
      * @parameter
      */
     private String strip;
 
     /**
      * {@inheritDoc}
      * 
      * @see org.apache.maven.plugin.AbstractMojo#execute()
      */
     public void execute()
         throws MojoExecutionException
     {
         DirectoryScanner scanner = getDirectoryScanner();
         scanner.scan();
         String[] files = scanner.getIncludedFiles();
 
         // if ( !Context.isValidOptimizationLevel( optimizationLevel ) )
         // {
         // throw new MojoExecutionException( "optimizationLevel is invalid" );
         // }
         // if ( !Context.isValidLanguageVersion( languageVersion ) )
         // {
         // throw new MojoExecutionException( "languageVersion is invalid" );
         // }
 
         JSCompressor jscompressor = getCompressor();
 
         logStats( HR );
         getOutputDirectory().mkdirs();
         long saved = 0;
         for ( int i = 0; i < files.length; i++ )
         {
             String file = files[i];
             saved = compress( jscompressor, file );
         }
         logStats( HR );
         logStats( "compression saved " + INTEGER.format( saved ) + " bytes" );
     }
 
     protected DirectoryScanner getDirectoryScanner() {
         DirectoryScanner scanner = new DirectoryScanner();
         scanner.setBasedir( getSourceDirectory() );
         if ( includes == null )
         {
             includes = DEFAULT_INCLUDES;
         }
         scanner.setIncludes( includes );
         scanner.addDefaultExcludes();
         if ( excludes != null )
         {
             scanner.setExcludes( excludes );
         }
         return scanner;
     }
 
     private File stripDebugs( String name, File file )
         throws MojoExecutionException
     {
         if ( strip == null && (strips == null || strips.length == 0))
         {
             return file;
         }
 
         File stripped = new File( getStrippedDirectory(), name );
         stripped.getParentFile().mkdirs();
         if ( file.equals( stripped ) )
         {
             try
             {
                 File temp = File.createTempFile( "stripped", ".js" );
                 stripDebugs(file, temp);
                 FileUtils.copyFile( temp, file );
                 temp.delete();
                 return file;
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Error creating temp file for stripping", e );
             }
         }
         else
         {
             stripDebugs(file, stripped);
             return stripped;
         }
     }
 
     private void stripDebugs( File file, File stripped )
             throws MojoExecutionException
     {
         try
         {
             BufferedReader reader = new BufferedReader( new FileReader( file ) );
             PrintWriter writer = new PrintWriter( stripped );
             String line;
             while ( ( line = reader.readLine() ) != null )
             {
                 String trimmed = line.trim();
                 boolean stripLine = (strip != null && trimmed.startsWith( strip ));
                 if( strips != null ) {
                     for( int i=0, len = strips.length; !stripLine && i < len; i++ ) {
                         stripLine = trimmed.startsWith( strips[i] );
                     }
                 }
                 if ( !stripLine )
                 {
                     writer.println( line );
                 }
             }
             IOUtil.close( reader );
             IOUtil.close( writer );
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "Failed to strip debug code in " + file, e );
         }
     }
 
     private JSCompressor getCompressor()
         throws MojoExecutionException
     {
         if ( compressors.containsKey( compressor ) )
         {
             return (JSCompressor) compressors.get( compressor );
         }
 
         // Inspired by the surefire plugin
         // allows to use multiple compressor that rely on modifier Rhino engines
         // without dependencies/classpath conflicts
 
         String id = compressor.toLowerCase() + "-compressor";
 
         // TODO don't have version hardcoded
         Artifact compressorArtifact =
             artifactFactory.createDependencyArtifact( "org.codehaus.mojo.javascript", id,
                 VersionRange.createFromVersion( "1.0-softec" ), "jar", null,
                 Artifact.SCOPE_RUNTIME );
 
         Artifact originatingArtifact =
             artifactFactory.createBuildArtifact( "dummy", "dummy", "1.0", "jar" );
 
         ArtifactResolutionResult dependencies;
         try
         {
             dependencies =
                 artifactResolver.resolveTransitively( Collections.singleton( compressorArtifact ),
                     originatingArtifact, localRepository, remoteRepositories, metadataSource, null );
         }
         catch ( Exception e )
         {
             getLog().info( "Failed to load compressor artifact " + compressorArtifact.toString() );
             throw new MojoExecutionException( "Failed to load compressor artifact"
                 + compressorArtifact.toString(), e );
         }
 
         IsolatedClassLoader classLoader = new IsolatedClassLoader( dependencies.getArtifacts(),
             this.getClass().getClassLoader() );
 
         compressor = StringUtils.capitalize( compressor );
         String compressorClassName =
             "org.codehaus.mojo.javascript.compress." + compressor + "Compressor";
         Class compressorClass;
         try
         {
             compressorClass = classLoader.loadClass( compressorClassName );
         }
         catch ( ClassNotFoundException e )
         {
             getLog().info( "Failed to load compressor class " + compressorClassName );
             throw new MojoExecutionException( "Failed to load compressor class"
                 + compressorClassName, e );
         }
 
         JSCompressor jscompressor;
         try
         {
             jscompressor = (JSCompressor) compressorClass.newInstance();
             jscompressor.setLogger(new MojoJSCompressorLogger(getLog()));
         }
         catch ( Exception e )
         {
             getLog().info(
                 "Failed to create a isolated-classloader proxy for " + compressorClassName );
             throw new MojoExecutionException( "Failed to create a isolated-classloader proxy for "
                 + compressorClassName, e );
         }
         getLog().info( "Compressing javascript using " + compressor );
 
         compressors.put( compressor, jscompressor );
         return jscompressor;
     }
 
     private long compress( JSCompressor jscompressor, String file )
         throws MojoExecutionException
     {
         String name = file;
         if ( getExtension() != null )
         {
             int ext = file.lastIndexOf( '.' );
             name = file.substring( 0, ext ) + "-" + getExtension() + file.substring( ext );
         }
         File compressed = new File( getOutputDirectory(), name );
         compressed.getParentFile().mkdirs();
         File in = new File( getSourceDirectory(), file );
         if ( in.equals( compressed ) )
         {
             try
             {
                 File temp = File.createTempFile( "compress", ".js" );
                 long size = compress( name, in, temp, jscompressor );
                 FileUtils.copyFile( temp, compressed );
                 temp.delete();
                 return size;
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Error creating temp file for compression", e );
             }
         }
         else
         {
             return compress( name, in, compressed, jscompressor );
         }
     }
 
     private long compress( String name, File in, File compressed, JSCompressor jscompressor )
         throws MojoExecutionException
     {
         if ( in.length() > 0 )
         {
             File stripped = stripDebugs( name, in );
             try
             {
                 jscompressor.compress( stripped, compressed, optimizationLevel, languageVersion );
             }
             catch ( CompressionException e )
             {
                 throw new MojoExecutionException( "Failed to compress Javascript file "
                     + e.getScript(), e );
             }
             String describe = in.getName() + " (" + INTEGER.format( in.length() ) + " bytes) ";
             String title = StringUtils.rightPad( describe, 50, "." );
             logStats( title + " compressed at " + ratio( compressed, in ) + "%" );
             return in.length() - compressed.length();
         }
         else
         {
             try
             {
                 compressed.createNewFile();
                 getLog().info( in.getName() + " was zero length; not compressed." );
                 return 0;
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Error handling zero length file.", e );
             }
         }
     }
 
     private long ratio( File compressed, File in )
     {
         long length = in.length();
         if ( length == 0 )
         {
             return 0;
         }
         return ( ( ( length - compressed.length() ) * 100 ) / length );
     }
 
     private void logStats( String line )
     {
         if ( skipStats )
         {
             return;
         }
         getLog().info( line );
     }
 
     /**
      * @return the extension to append to compressed scripts.
      */
     public abstract String getExtension();
 
     /**
      * @return the outputDirectory
      */
     protected abstract File getOutputDirectory();
 
     /**
      * @return the outputDirectory
      */
     protected abstract File getStrippedDirectory();
 
     /**
      * @return the sourceDirectory
      */
     protected abstract File getSourceDirectory();
 
     protected void setLocalRepository( ArtifactRepository localRepository )
     {
         this.localRepository = localRepository;
     }
 }