/*
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2000 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowlegement:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowlegement may appear in the software itself,
 *    if and wherever such third-party acknowlegements normally appear.
 *
 * 4. The names "The Jakarta Project", "Ant", and "Apache Software
 *    Foundation" must not be used to endorse or promote products derived
 *    from this software without prior written permission. For written
 *    permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache"
 *    nor may "Apache" appear in their names without prior written
 *    permission of the Apache Group.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */

/**
 * jlink.java
 * links together multiple .jar files
 * 
 * Original code by Patrick Beard. Modifications to work
 * with ANT by Matthew Kuperus Heun.
 *
 * @author <a href="mailto:beard@netscape.com>Patrick C. Beard</a>.
 * @author <a href="mailto:matthew.k.heun@gaerospace.com>Matthew Kuperus Heun</a>
 */
package org.apache.tools.ant.taskdefs.optional.jlink;

import java.io .*;
import java.util .Enumeration;
import java.util .Vector;
import java.util.zip .*;

public class jlink extends Object{

    /**
     * The file that will be created by this instance of jlink.
     */
    public  void setOutfile( String outfile ) {
        if ( outfile == null ) {
            return ;
        }
        this .outfile = outfile;
    }

    /**
     * Adds a file to be merged into the output.
     */
    public  void addMergeFile( String mergefile ) {
        if ( mergefile == null ) {
            return ;
        }
        mergefiles .addElement( mergefile );
    }

    /**
     * Adds a file to be added into the output.
     */
    public  void addAddFile( String addfile ) {
        if ( addfile == null ) {
            return ;
        }
        addfiles .addElement( addfile );
    }

    /**
     * Adds several files to be merged into the output.
     */
    public  void addMergeFiles( String[] mergefiles ) {
        if ( mergefiles == null ) {
            return ;
        }
        for ( int i = 0; i < mergefiles .length; i++ ) {
            addMergeFile( mergefiles[i] );
        }
    }

    /**
     * Adds several file to be added into the output.
     */
    public  void addAddFiles( String[] addfiles ) {
        if ( addfiles == null ) {
            return ;
        }
        for ( int i = 0; i < addfiles .length; i++ ) {
            addAddFile( addfiles[i] );
        }
    }

    /**
     * Determines whether output will be compressed.
     */
    public  void setCompression( boolean compress ) {
        this .compression = compress;
    }

    /**
     * Performs the linking of files.
     * Addfiles are added to the output as-is. For example, a 
     * jar file is added to the output as a jar file.
     * However, mergefiles are first examined for their type.
     * If it is a jar or zip file, the contents will be extracted
     * from the mergefile and entered into the output.
     * If a zip or jar file is encountered in a subdirectory
     * it will be added, not merged.
     * If a directory is encountered, it becomes the root
     * entry of all the files below it.  Thus, you can
     * provide multiple, disjoint directories, as
     * addfiles: they will all be added in a rational 
     * manner to outfile.
     */
    public  void link() throws Exception {
        ZipOutputStream output = new ZipOutputStream( new FileOutputStream( outfile ) );
        if ( compression ) {
            output .setMethod( ZipOutputStream .DEFLATED );
            output .setLevel( Deflater .DEFAULT_COMPRESSION );
        } else {
            output .setMethod( ZipOutputStream .STORED );
        }
        Enumeration merges = mergefiles .elements();
        while ( merges .hasMoreElements() ) {
            String path = (String) merges .nextElement();
            File f = new File( path );
            if ( f.getName().endsWith( ".jar" ) || f.getName().endsWith( ".zip" ) ) {
                                //Do the merge
                mergeZipJarContents( output, f );
            }
            else {
                //Add this file to the addfiles Vector and add it 
                //later at the top level of the output file.
                addAddFile( path );
            }
        }
        Enumeration adds = addfiles .elements();
        while ( adds .hasMoreElements() ) {
            String name = (String) adds .nextElement();
            File f = new File( name );
            if ( f .isDirectory() ) {
                //System.out.println("in jlink: adding directory contents of " + f.getPath());
                addDirContents( output, f, f.getName() + '/', compression );
            }
            else {
                addFile( output, f, "", compression );
            }
        }
        if ( output != null ) {
            try  {
                output .close();
            } catch( IOException ioe ) {}
        }
    }

    public static  void main( String[] args ) {
        // jlink output input1 ... inputN
        if ( args .length < 2 ) {
            System .out .println( "usage: jlink output input1 ... inputN" );
            System .exit( 1 );
        }
        jlink linker = new jlink();
        linker .setOutfile( args[0] );
        //To maintain compatibility with the command-line version, we will only add files to be merged.
        for ( int i = 1; i < args .length; i++ ) {
            linker .addMergeFile( args[i] );
        }
        try  {
            linker .link();
        } catch( Exception ex ) {
            System .err .print( ex .getMessage() );
        }
    }

    /*
     * Actually performs the merging of f into the output.
     * f should be a zip or jar file.
     */
    private void mergeZipJarContents( ZipOutputStream output, File f ) throws IOException {
        //Check to see that the file with name "name" exists.
        if ( ! f .exists() ) {
            return ;
        }
        ZipFile zipf = new ZipFile( f );
        Enumeration entries = zipf.entries();
        while (entries.hasMoreElements()){
            ZipEntry inputEntry = (ZipEntry) entries.nextElement();
            //Ignore manifest entries.  They're bound to cause conflicts between
            //files that are being merged.  User should supply their own
            //manifest file when doing the merge.
            String inputEntryName = inputEntry.getName();
            int index = inputEntryName.indexOf("META-INF");
            if (index < 0){
                //META-INF not found in the name of the entry. Go ahead and process it.
                try {
                    output.putNextEntry(processEntry(zipf, inputEntry));
                } catch (ZipException ex){
                    //If we get here, it could be because we are trying to put a
                    //directory entry that already exists.
                    //For example, we're trying to write "com", but a previous
                    //entry from another mergefile was called "com".
                    //In that case, just ignore the error and go on to the
                    //next entry.
                    String mess = ex.getMessage();
                    if (mess.indexOf("duplicate") >= 0){
                                //It was the duplicate entry.
                        continue;
                    } else {
                                //I hate to admit it, but we don't know what happened here.  Throw the Exception.
                        throw ex;
                    }
                }
                InputStream in = zipf.getInputStream(inputEntry);
                int len = buffer.length;
                int count = -1;
                while ((count = in.read(buffer, 0, len)) > 0){
                    output.write(buffer, 0, count);
                }
                in.close();
                output.closeEntry();
            }
        }
        zipf .close();
    }

    /*
     * Adds contents of a directory to the output.
     */
    private void addDirContents( ZipOutputStream output, File dir, String prefix, boolean compress ) throws IOException {
        String[] contents = dir .list();
        for ( int i = 0; i < contents .length; ++i ) {
            String name = contents[i];
            File file = new File( dir, name );
            if ( file .isDirectory() ) {
                addDirContents( output, file, prefix + name + '/', compress );
            }
            else {
                addFile( output, file, prefix, compress );
            }
        }
    }

    /*
     * Gets the name of an entry in the file.  This is the real name
     * which for a class is the name of the package with the class
     * name appended.
     */
    private String getEntryName( File file, String prefix ) {
        String name = file .getName();
        if ( ! name .endsWith( ".class" ) ) {
            // see if the file is in fact a .class file, and determine its actual name.
            try  {
                InputStream input = new FileInputStream( file );
                String className = ClassNameReader .getClassName( input );
                input .close();
                if ( className != null ) {
                    return className .replace( '.', '/' ) + ".class";
                }
            } catch( IOException ioe ) {}
        }
        System.out.println("From " + file.getPath() + " and prefix " + prefix + ", creating entry " + prefix+name);
        return (prefix + name);
    }

    /*
     * Adds a file to the output stream.
     */
    private void addFile( ZipOutputStream output, File file, String prefix, boolean compress) throws IOException {
        //Make sure file exists
        long checksum = 0;
        if ( ! file .exists() ) {
            return ;
        }
        ZipEntry entry = new ZipEntry( getEntryName( file, prefix ) );
        entry .setTime( file .lastModified() );
        entry .setSize( file .length() );
        if (! compress){
            entry.setCrc(calcChecksum(file));
        }
        FileInputStream input = new FileInputStream( file );
        addToOutputStream(output, input, entry);
    }
        
    /*
     * A convenience method that several other methods might call.
     */
    private void addToOutputStream(ZipOutputStream output, InputStream input, ZipEntry ze) throws IOException{
        try {
            output.putNextEntry(ze);            
        } catch (ZipException zipEx) {
            //This entry already exists. So, go with the first one.
            input.close();
            return;
        }
        int numBytes = -1;
        while((numBytes = input.read(buffer)) > 0){
            output.write(buffer, 0, numBytes);
        }
        output.closeEntry();
        input.close();
    }

    /*
     * A method that does the work on a given entry in a mergefile.
     * The big deal is to set the right parameters in the ZipEntry 
     * on the output stream.
     */
    private ZipEntry processEntry( ZipFile zip, ZipEntry inputEntry ) throws IOException{
        /*
          First, some notes.
          On MRJ 2.2.2, getting the size, compressed size, and CRC32 from the
          ZipInputStream does not work for compressed (deflated) files.  Those calls return -1.
          For uncompressed (stored) files, those calls do work.
          However, using ZipFile.getEntries() works for both compressed and 
          uncompressed files.
            
          Now, from some simple testing I did, it seems that the value of CRC-32 is
          independent of the compression setting. So, it should be easy to pass this 
          information on to the output entry.
        */
        String name = inputEntry .getName();
        if ( ! (inputEntry .isDirectory() || name .endsWith( ".class" )) ) {
            try  {
                InputStream input = zip.getInputStream( zip .getEntry( name ) );
                String className = ClassNameReader .getClassName( input );
                input .close();
                if ( className != null ) {
                    name = className .replace( '.', '/' ) + ".class";
                }
            } catch( IOException ioe ) {}
        }
        ZipEntry outputEntry = new ZipEntry( name );
        outputEntry.setTime(inputEntry .getTime() );
        outputEntry.setExtra(inputEntry.getExtra());
        outputEntry.setComment(inputEntry.getComment());
        outputEntry.setTime(inputEntry.getTime());
        if (compression){
            outputEntry.setMethod(ZipEntry.DEFLATED);
            //Note, don't need to specify size or crc for compressed files.
        } else {
            outputEntry.setMethod(ZipEntry.STORED);
            outputEntry.setCrc(inputEntry.getCrc());
            outputEntry.setSize(inputEntry.getSize());
        }
        return outputEntry;
    }
        
    /*
     * Necessary in the case where you add a entry that
     * is not compressed.
     */
    private long calcChecksum(File f) throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(f));
        return calcChecksum(in, f.length());
    }

    /*
     * Necessary in the case where you add a entry that
     * is not compressed.
     */
    private long calcChecksum(InputStream in, long size) throws IOException{
        CRC32 crc = new CRC32();
        int len = buffer.length;
        int count = -1;
        int haveRead = 0; 
        while((count=in.read(buffer, 0, len)) > 0){
            haveRead += count;
            crc.update(buffer, 0, count);
        }
        in.close();
        return crc.getValue();
    }

    private  String outfile = null;

    private  Vector mergefiles = new Vector( 10 );

    private  Vector addfiles = new Vector( 10 );

    private  boolean compression = false;
        
    byte[] buffer = new byte[8192];

}