package com.randomnoun.common;

/* (c) 2013 randomnoun. All Rights Reserved. This work is licensed under a
 * BSD Simplified License. (http://www.randomnoun.com/bsd-simplified.html)
 */

import java.io.BufferedReader;
import java.io.EOFException;
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.InputStreamReader;
import java.io.LineNumberReader;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipInputStream;

import org.apache.log4j.Logger;

/** Find a resource recursively through all JARs, EARs, WARs, etc from
 * the current directory down.
 * 
 * <p>Command-line usage</p>
 *
 * <p>The following command-line arguments are recognised 
 *
<table>
<caption>Usage</caption>
<tr><th> -h -?     <td>displays this helptext
<tr><th> -f        <td>follow symlinks
<tr><th> -a        <td>show all resources found (i.e. do not use searchTerm)
<tr><th>
<tr><th colspan="2">Search criteria:
<tr><th> -i        <td>case-insensitive match
<tr><th> -sc       <td>if present, searchTerm matches within filename (default)
<tr><th> -ss       <td>if present, searchTerm matches start of filename
<tr><th> -se       <td>if present, searchTerm matches exact filename
<tr><th> -sr       <td>if present, searchTerm matches filename as a regular expression
<tr><th> -mf n     <td>max filesystem folder depth (0 = do not descend into subfolders)
<tr><th> -ma n     <td>max archive depth (0 = do not descend into archives)
<tr><th> -x        <td>if present, will attempt to recover if errors occur reading archives
                       (errors sent to stderr)
<tr><th>
<tr><th colspan="2">Action when resource found:
<tr><th> -v        <td>verbose; display filenames with file sizes and timestamps
<tr><th> -vv       <td>display MD5/SHA1 hashes of resources (NB: modifies display order)
<tr><th> -d n      <td>dump/display the contents of the n'th resource found
<tr><th> -d all    <td>dump the name and contents of all resources found
<tr><th> -d names  <td>dump just the names of all resources found (default)
<tr><th> -d n1,n2...<td>dump the name and contents of the n1'th, n2'nd etc... resources found
<tr><th> -dm n|all <td>as per -d, but performs manifest unmangling on resource (fixes linewraps)
<tr><th> -dj n|all <td>as per -d, but performs class decompiling (requires jad to be in PATH)
<tr><th> -c text   <td>search for text in contents of resource (uses UTF-8 encoding)
<tr><th> -ci text  <td>case-insensitive search for text in contents of resources
</table>

 * 
 * <p><b>TODO</b> split CLI functionality into separate class
 * <p><b>TODO</b> pass enough information to the callback classes to display somewhat sane progress bar 
 * <p><b>TODO</b> fix -dj switch + handle inner classes
 * <p><b>TODO</b> rewrite jad to deal with annotations and other 1.5+ crap
 * <p><b>TODO</b> -cs switches to change search behaviour within content
 * 
 * @author knoxg
 * 
 */
public class ResourceFinder {

        /** Logger instance for this class */
        Logger logger = Logger.getLogger(ResourceFinder.class);

        /** Match type used in {@link #matches(String)}} comparisons that tests whether
         * the last component of a resource name contains a specified string; e.g. 
         * "abc/def.txt" will match against the searchTerm "ef" using this matchType.
         */
        public final static int MATCHTYPE_CONTAINS = 0;
        
        /** Match type used in {@link #matches(String)}} comparisons that tests whether
         * the last component of a resource name starts with a specified string; e.g. 
         * "abc/def.txt" will match against the searchTerm "de" using this matchType.
         */
        public final static int MATCHTYPE_STARTSWITH = 1;
        
        /** Match type used in {@link #matches(String)}} comparisons that tests whether
         * the last component of a resource name is equal to a specified regular expression; e.g. 
         * "abc/def.txt" will match against the searchTerm "def.txt" using this matchType.
         */
        public final static int MATCHTYPE_EXACT = 2;

        /** Match type used in {@link #matches(String)}} comparisons that tests whether
         * the last component of a resource name matches a specified regular expression; e.g. 
         * "abc/def.txt" will match against the searchTerm ".*e.*" using this matchType.
         */
        public final static int MATCHTYPE_REGEX = 3;

        /** Resource being searched for */
        private String searchTerm;
        
        /** If performing regex searches, the Pattern form of {@link #searchTerm} */
        private Pattern searchPattern;
        
        /** File or directory from which search begins. If this is null, {@link #startInputStream} must be non-null, and vice versa */
        private File startDirectory;
        
        /** ZipInputStream from which search begins.  If this is null, {@link #startDirectory} must be non-null, and vice versa*/ 
        private ZipInputStream startInputStream;
        
        /** A MATCHTYPE_* constant. */
        private int matchType;

        /** If true, performs a case-insensitive match */
        private boolean ignoreCase = false;
        
        /** If false, will prevent recursive search from following symbolic links */ 
        private boolean followSymlinks = false;

        /** If true, will invoke the ResourceFinderCallback for every file in every archive iterated over 
         * (i.e. the {@link #searchTerm} will be ignored) */ 
        private boolean showAll = false;
        
        /** If true, will attempt to recover processing after reading an invalid ZIP entry */
        private boolean ignoreErrors = false;
        
        /** Maximum depth; -1 = no depth limit. See {@link #setMaxArchiveDepth(long)}. <i>(Not implemented)</i>*/
        private long maxArchiveDepth = -1;
        
        /** Maximum folder depth; -1 = no depth limit. See {@link #setMaxFolderDepth(long)}. */
        private long maxFolderDepth = -1;
        
        /** Current archive depth */
        private long currentArchiveDepth = -1;
        
        /** Current folder depth */
        private long currentFolderDepth = -1;
        
        /** Callback to be invoked on every resource that matches the search criteria */
        private ResourceFinderCallback callback;
        
        /** If set to true, allows the search to be aborted whilst it is in progress */
        private transient boolean abort = false;
        
        /** Regex to define which files will be opened via ZipInputStream. Will return true if the file ends with
         * .zip, .sar, .jar, .war, .ear, .rar or .har. These are Java RARs (resource archives), not the other type
         * of RAR. */
        private Pattern isArchivePattern = Pattern.compile(
                ".*\\.([Zz][Ii][Pp]|" +
                "[SsJjWwEeRrHh][Aa][Rr])$");
        
        /** Call this method within a {@link ResourceFinderCallback} to stop looking for resources */
        public void abort() { this.abort = true; }
        
        /** Return the file or directory from which search begins. If this returns null, try {@link #getStartInputStream()} */
        public File getStartDirectory() { return startDirectory; }
        
        /** Return the ZipInputStream from which search begins.  If this returns null, try {@link #getStartDirectory()} */ 
        public InputStream getStartInputStream() { return startInputStream; }
        
        /** Tests a resource name against the search criteria specified in this object
         * 
         * @param resourceName the last component of a resource name
         * 
         * @return true if the resource passes the search criteria, false otherwise
         */
        public boolean matches(String resourceName) {
                if (resourceName==null) { throw new NullPointerException("null string"); }
                if (ignoreCase) {
                        switch(matchType) {
                                case MATCHTYPE_EXACT: return searchTerm.equalsIgnoreCase(resourceName);
                                case MATCHTYPE_REGEX: return searchPattern.matcher(resourceName).find();
                                case MATCHTYPE_STARTSWITH: return resourceName.toUpperCase().startsWith(searchTerm);
                                case MATCHTYPE_CONTAINS: return resourceName.toUpperCase().contains(searchTerm);
                                default: throw new IllegalStateException("Illegal matchType '" + matchType + "'");
                        }
                } else {
                        switch(matchType) {
                                case MATCHTYPE_EXACT: return searchTerm.equals(resourceName);
                                case MATCHTYPE_REGEX: return searchPattern.matcher(resourceName).find();
                                case MATCHTYPE_STARTSWITH: return resourceName.startsWith(searchTerm);
                                case MATCHTYPE_CONTAINS: return resourceName.contains(searchTerm);
                                default: throw new IllegalStateException("Illegal matchType '" + matchType + "'");
                        }
                }
        }
        

        /** An {@link java.io.InputStream} wrapper which updates an internal md5/sha1 digest
         * as the stream is being read.
         */
        public static class HashGeneratingInputStream extends InputStream {
                InputStream is;
                MessageDigest algorithm1, algorithm2;
                
                public HashGeneratingInputStream(InputStream is) {
                        this.is = is;
                        try {
                                algorithm1 = MessageDigest.getInstance("MD5");
                                algorithm2 = MessageDigest.getInstance("SHA-1");
                        } catch (NoSuchAlgorithmException nsae) {
                                throw (IllegalStateException) new IllegalStateException(
                                        "Invalid crypto config").initCause(nsae);
                        }
                algorithm1.reset();
                algorithm2.reset();

                }
                
                @Override
                public int read() throws IOException {
                        int result = is.read();
                        if (result != -1) {
                                algorithm1.update((byte) result);
                                algorithm2.update((byte) result);
                        }
                        return result;
                }
                public int available() throws IOException {
                        return is.available();
                }
                public void close() {
                        // ignored;
                }
                public void mark(int readlimit) {
                        is.mark(readlimit);
                }
        public boolean markSupported() {
                return is.markSupported();
        }
        public int read(byte[] b)  throws IOException {
                int result = is.read(b);
                if (result!=-1) {
                        algorithm1.update(b, 0, result);
                        algorithm2.update(b, 0, result);
                }
                return result;
        }
        public int read(byte[] b, int off, int len)  throws IOException {
                int result = is.read(b, off, len);
                if (result!=-1) {
                        algorithm1.update(b, off, result);
                        algorithm2.update(b, off, result);
                }
                        return result;
        }
        public void reset() throws IOException {
                is.reset();
        }
        public long skip(long n) throws IOException {
                return is.skip(n);
        }
        /** Returns the MD5 digest of all input that has been read by this InputStream so far,
         * in a hexadecimal String form */
        public String getMd5() {
                byte messageDigest[] = algorithm1.digest();
                //System.err.println("md5 messageDigest is " + messageDigest.length + " bytes");
                StringBuffer hexString = new StringBuffer();
                for (int i=0;i<messageDigest.length;i++) {
                        hexString.append(Integer.toString( ( messageDigest[i] & 0xff ) + 0x100, 16).substring( 1 ));
                }
                return hexString.toString();
        }
        /** Returns the SHA1 digest of all input that has been read by this InputStream so far,
         * in a hexadecimal String form */
                public String getSha1() {
                byte messageDigest[] = algorithm2.digest();
                //System.err.println("sha1 messageDigest is " + messageDigest.length + " bytes");
                StringBuffer hexString = new StringBuffer();
                for (int i=0;i<messageDigest.length;i++) {
                        hexString.append(Integer.toString( ( messageDigest[i] & 0xff ) + 0x100, 16).substring( 1 ));
                }
                return hexString.toString();
        }
        }
        

        public static class ResourceFinderCallbackResult {
                boolean abort = false;
                InputStream replaceInputStream = null;
        }
        
        /** A callback interface used when resources are found using this object
         * 
         */
        public interface ResourceFinderCallback {

                /** This method is only invoked for archive resources, before that archive has been read or
                 * recursed into. Both archives and standard files will be passed to the 
                 * {@link #postProcess(String, long, long, InputStream, ResourceFinderCallbackResult)} method.  
                 * 
                 * @param resourceName full resource name
                 * @param filesize the size of the (uncompressed) resource, or -1 if this is unknown
                 *   (some archives do not store this information) 
                 * @param timestamp the timestamp of the resource 
                 * @param inputStream an inputStream which can be used to retrieve the contents
                 *   of the resource
                 *   
                 * @return a ResourceFinderCallbackResult which can be used to abort the search or 
                 *   modify/wrap the inputStream being searched.
                 * 
                 * @throws IOException
                 */
                public ResourceFinderCallbackResult preProcess(String resourceName, long filesize, long timestamp, 
                        InputStream inputStream) throws IOException;

                /** This method is invoked for each resource that matches the search criteria
                 * specified in the containing {@link ResourceFinder} class. This method
                 * is not responsible for closing the supplied inputStream.
                 *  
                 * @param resourceName full resource name
                 * @param filesize the size of the (uncompressed) resource, or -1 if this is unknown
                 *   (some archives do not store this information) 
                 * @param timestamp the timestamp of the resource 
                 * @param inputStream an inputStream which can be used to retrieve the contents
                 *   of the resource
                 * 
                 * @return a ResourceFinderCallbackResult which can be used to abort the search
                 * 
                 * @throws IOException if an operation on the <code>inputStream</code> fails 
                 */
                public ResourceFinderCallbackResult postProcess(String resourceName, long filesize, long timestamp, 
                        InputStream inputStream, ResourceFinderCallbackResult preProcessResult) throws IOException;
                
        }

        /** Class which defines a callback which sends names and resource hashes to System.out.
         */
        public static class HashingResourceFinderCallback implements ResourceFinderCallback {
                
                int resourceIndex = 0;
                boolean showHashes = false;
                boolean ignoreErrors = false;
        
                public HashingResourceFinderCallback(boolean ignoreErrors) {
                        this.ignoreErrors = ignoreErrors;
                }
                
                public void ignorableException(String message, Exception e) throws ZipException {
                        if (ignoreErrors) {
                                Logger.getLogger(HashingResourceFinderCallback.class).error(message, e);
                        } else {
                                throw (ZipException) new ZipException(message).initCause(e);
                        }
                }
                
                public ResourceFinderCallbackResult preProcess(String resourceName, long filesize, long timestamp, InputStream inputStream) throws IOException {
                        ResourceFinderCallbackResult rfcbr = new ResourceFinderCallbackResult();
                        rfcbr.replaceInputStream = new HashGeneratingInputStream(inputStream);
                        return rfcbr;
                }
                
                public ResourceFinderCallbackResult postProcess(String resourceName, long filesize, long timestamp, InputStream inputStream, ResourceFinderCallbackResult preProcessResult) throws IOException {
                        ResourceFinderCallbackResult rfcbr = new ResourceFinderCallbackResult();
                        try {
                                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                String md5, sha1;
                                if (inputStream instanceof HashGeneratingInputStream) {
                                        HashGeneratingInputStream hgis = (HashGeneratingInputStream) inputStream;
                                        // pump the rest of the bits through this stream
                                        byte[] buffer = new byte[4096];
                                        try {
                                                
                                                while (inputStream.read(buffer) != -1) { /* nothing */ }
                                        } catch (EOFException eofe) {
                                                ignorableException("Error reading zip resource '" + resourceName + "' for hash", eofe);
                                        } catch (ZipException ze) {
                                                // can trigger "java.util.zip.ZipException: invalid distance code"
                                                ignorableException("Error reading zip resource '" + resourceName + "' for hash", ze);
                                        } 
                                        
                                        md5 = hgis.getMd5();
                                        sha1 = hgis.getSha1();
                                } else {
                                        MessageDigest algorithm1, algorithm2;
                                        try {
                                                algorithm1 = MessageDigest.getInstance("MD5");
                                                algorithm2 = MessageDigest.getInstance("SHA1");
                                        } catch (NoSuchAlgorithmException nsae) {
                                                throw (IllegalStateException) new IllegalStateException(
                                                        "Invalid crypto config").initCause(nsae);
                                        }
                                algorithm1.reset();
                                algorithm2.reset();
                                        byte[] buffer = new byte[4096];
                                        int bytesRead;
                                        try {
                                                while ((bytesRead = inputStream.read(buffer)) != -1) {
                                                        algorithm1.update(buffer, 0, bytesRead);
                                                        algorithm2.update(buffer, 0, bytesRead);
                                        }
                                        } catch (EOFException eofe) {
                                                // can trigger "java.io.EOFException: Unexpected end of ZLIB input stream" errors
                                                ignorableException("Error hashing zip resource '" + resourceName + "'", eofe);
                                        } catch (ZipException ze) {
                                                ignorableException("Error hashing zip resource '" + resourceName + "'", ze);
                                        } 
                                byte messageDigest1[] = algorithm1.digest();
                                byte messageDigest2[] = algorithm2.digest();
                                StringBuffer hexString1 = new StringBuffer();
                                StringBuffer hexString2 = new StringBuffer();
                                for (int i=0; i<messageDigest1.length; i++) {
                                        hexString1.append(Integer.toString( ( messageDigest1[i] & 0xff ) + 0x100, 16).substring( 1 ));
                                }
                                for (int i=0; i<messageDigest2.length; i++) {
                                        hexString2.append(Integer.toString( ( messageDigest2[i] & 0xff ) + 0x100, 16).substring( 1 ));
                                }
                                md5 = hexString1.toString();
                                sha1 = hexString2.toString();
                                }
                        System.out.println("[" + resourceIndex + "] " + resourceName + " " + (filesize==-1 ? "(unknown)" : String.valueOf(filesize)) + 
                                " " + sdf.format(new Date(timestamp)) + " " + md5 + " " + sha1 );
                        } catch (IllegalArgumentException iae) {
                                // not sure if this is needed any more
                                throw new IOException("IllegalArgumentException processing ZipInputStream", iae);
                        }
                        resourceIndex++;
                        return rfcbr;
                }
        }

        
        /** Class which defines a callback which sends names and resources to System.out.
         * 
         * <p>This class uses '#' as a separator between the filesystem and files contained
         * within archives; e.g. test.jar#abc.txt refers to abc.txt in test.jar.
         * 
         * <p>For comparison, Tangosol seems to use '!', includes a leading slash and 
         * includes a protocol-like identifier at the beginning
         * (e.g. jar:file:test.jar!/abc.txt). If a constructor is supplied which only provides
         * a ZipInputStream (i.e. no filename is available), then resources will be returned 
         * starting with the '#' character.
         * 
         */
        public static class DisplayResourceFinderCallback implements ResourceFinderCallback {
                
                public final static int DUMP_NAMES = -1;
                public final static int DUMP_NAMES_AND_RESOURCES = -2;
                public final static int DUMP_RESOURCES = 0;
        
                int dumpType = 0;
                List<Integer> dumpResourceNumbers;
                int maxDumpResourceNumber = -1;
                int resourceIndex = 0;
                boolean verbose = false;
                boolean manifests = false;
                boolean decompile = false;
                String searchContents = null;
                boolean searchContentsIgnoreCase = false;

                // with all the trimmings
                public DisplayResourceFinderCallback(int dumpType, List<Integer> dumpResourceNumbers, boolean verbose, boolean manifests, boolean decompile, String searchContents, boolean searchContentsIgnoreCase) {
                        // System.out.println("2 searchContents is " + searchContents);
                        this.dumpResourceNumbers = dumpResourceNumbers;
                        this.dumpType = dumpType;
                        this.verbose = verbose;
                        this.manifests = manifests;
                        this.decompile = decompile;
                        this.searchContents = searchContents;
                        this.searchContentsIgnoreCase = searchContentsIgnoreCase;
                        if (dumpResourceNumbers != null) {
                                for (Integer drn : dumpResourceNumbers) {
                                        maxDumpResourceNumber = Math.max(maxDumpResourceNumber, drn.intValue());
                                }
                        }
                }
                
                private ResourceFinderCallbackResult dump(String resourceName, long filesize, long timestamp, InputStream inputStream) throws IOException {
                        ResourceFinderCallbackResult rfcr = new ResourceFinderCallbackResult(); 
                        if ((dumpType == DUMP_NAMES_AND_RESOURCES || dumpType == DUMP_NAMES) &&
                                (dumpResourceNumbers==null || dumpResourceNumbers.contains(new Integer(resourceIndex)))
                           )
                        {
                                if (verbose) {
                                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                        System.out.println("[" + resourceIndex + "] " + resourceName + " " + (filesize==-1 ? "(unknown)" : String.valueOf(filesize)) + " " + sdf.format(new Date(timestamp)));
                                } else if (searchContents == null) {
                                        System.out.println("[" + resourceIndex + "] " + resourceName);
                                } else if (searchContents != null) {
                                        int pos = -1;
                                        // @TODO this assumes we never search for strings containing newlines
                                        LineNumberReader lnr = new LineNumberReader(new InputStreamReader(inputStream));
                                        if (searchContentsIgnoreCase) {
                                                searchContents = searchContents.toLowerCase();
                                                String line = lnr.readLine();
                                                if (line!=null) {
                                                        pos = line.toString().toLowerCase().indexOf(searchContents.toLowerCase());
                                                        while (line!=null && pos==-1) {
                                                                line = lnr.readLine();
                                                                pos = line==null ? -1 : line.toString().toLowerCase().indexOf(searchContents.toLowerCase());
                                                        }
                                                }
                                        } else {
                                                String line = lnr.readLine();
                                                if (line!=null) {
                                                        pos = line.toString().indexOf(searchContents);
                                                        while (line!=null && pos==-1) {
                                                                line = lnr.readLine();
                                                                pos = line==null ? -1 :  line.toString().indexOf(searchContents);
                                                        }
                                                }
                                        }
                                        if (pos!=-1) {
                                                System.out.println("[" + resourceIndex + "] [line " + lnr.getLineNumber() + ", col " + pos + "] " + resourceName);
                                        }
                                }
                        }  
                        if ((dumpType == DUMP_NAMES_AND_RESOURCES || dumpType == DUMP_RESOURCES) &&
                                (dumpResourceNumbers==null || dumpResourceNumbers.contains(new Integer(resourceIndex)))
                                ) {
                                // InputStream is = ResourceFinder.getResourceStream(resourceName);
                                if (manifests) {
                                        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
                                        String line = br.readLine();
                                        while (line != null) {
                                                int len = line.length();
                                                while (line.length() > 0 && line.charAt(0) == ' ') {
                                                        line = line.substring(1);
                                                }
                                                System.out.print(line);
                                                if (len != 70) { System.out.println(); }
                                                line = br.readLine();
                                        }
                                } else if (decompile) {
                                        // hopefully this is deleted when the VM exits
                                        // @TODO: we need to grab all inner classes for this class as well
                                        File tmpFile = File.createTempFile("resourceFinder", ".class");
                                        FileOutputStream fos = new FileOutputStream(tmpFile); 
                                        StreamUtil.copyStream(inputStream, fos, 1024);
                                        fos.close();
                                        try {
                                                ProcessUtil processUtil = new ProcessUtil();
                                                String result = processUtil.exec(new String[] { "jad", "-lnc", "-p", tmpFile.getCanonicalPath() });
                                                System.out.println(result);
                                        } catch (ProcessUtil.ProcessException pe) {
                                                throw (IOException) new IOException("Problem executing jad").initCause(pe);
                                        }
                                        
                                } else {
                                        StreamUtil.copyStream(inputStream, System.out, 1024);
                                }
                                if (resourceIndex == maxDumpResourceNumber) {
                                        // don't bother continuing this search if we're found the last resource being searched for
                                        rfcr.abort = true;
                                }

                                // we don't insert an additional newline when dumping the contents of just one file
                                // so that stdout redirection still does something useful
                                if (dumpType == DUMP_NAMES_AND_RESOURCES && 
                                        (dumpResourceNumbers==null || dumpResourceNumbers.size()>1)) {
                                        System.out.println();
                                }
                        }
                        resourceIndex++;
                        return rfcr;
                }

                public ResourceFinderCallbackResult preProcess(String resourceName, long filesize, long timestamp, InputStream inputStream) throws IOException {
                        return dump(resourceName, filesize, timestamp, inputStream);
                }
                
                // won't be needing this one
                public ResourceFinderCallbackResult postProcess(String resourceName, long filesize, long timestamp, InputStream inputStream, ResourceFinderCallbackResult preProcessResult) throws IOException {
                        if (preProcessResult==null) { return dump(resourceName, filesize, timestamp, inputStream); }
                        return null;
                }
                
                
        }
        
        /** Creates a new resource finder object
         * 
         * @param searchTerm resource being searched for
         * @param matchType a MATCHTYPE_* constant denoting how the searchTerm is to be used to match against resource names
         * @param ignoreCase if true, will perform a case insensitive search 
         * @param startDirectory directory from which search begins
         * @param callback callback to be invoked on every resource that matches the search criteria
         * 
         * @throws IOException if the start directory is invalid
         */
        public ResourceFinder(String searchTerm, int matchType, boolean ignoreCase, File startDirectory, ResourceFinderCallback callback) throws IOException {
                init(searchTerm, matchType, ignoreCase, callback);
                this.startDirectory = startDirectory.getCanonicalFile(); // for symlink test

        }
        
        /** Common code to both the File and ZipInputStream constructors */
        private void init(String searchTerm, int matchType, boolean ignoreCase, 
                ResourceFinderCallback callback) 
        {
                this.matchType = matchType;
                this.ignoreCase = ignoreCase;
                this.showAll = false;
                this.ignoreErrors = false;
                this.callback = callback;

                // @TODO clean this up a bit
                if (ignoreCase) {
                        switch (matchType) {
                                case MATCHTYPE_EXACT: break;
                                case MATCHTYPE_REGEX: searchPattern = Pattern.compile(searchTerm, Pattern.CASE_INSENSITIVE); break;
                                case MATCHTYPE_STARTSWITH: searchTerm = searchTerm.toUpperCase(); break;
                                case MATCHTYPE_CONTAINS: searchTerm = searchTerm.toUpperCase(); break;
                                default: throw new IllegalStateException("Illegal matchType '" + matchType + "'");
                        }
                } else {
                        switch (matchType) {
                                case MATCHTYPE_EXACT: break;
                                case MATCHTYPE_REGEX: searchPattern = Pattern.compile(searchTerm); break;
                                case MATCHTYPE_STARTSWITH: break;
                                case MATCHTYPE_CONTAINS: break;
                                default: throw new IllegalStateException("Illegal matchType '" + matchType + "'");
                        }
                }
                this.searchTerm = searchTerm;
                
        }

        /** Sets whether to follow symbolic links during filesystem scans. By default symlinks will not be followed.
         * 
         * @see #getFollowSymlinks()
         * 
         * @param followSymlinks true if symbolic links should be followed during filesystem scans, false otherwise 
         */
        public void setFollowSymLinks(boolean followSymlinks) {
                this.followSymlinks = followSymlinks;
        }
        
        /** Returns whether symbolic links will be followed during filesystem scans
         *
         * @see #setFollowSymLinks(boolean)
         *  
         * @return whether symbolic links will be followed during filesystem scans
         */
        public boolean getFollowSymlinks() {
                return followSymlinks;
        }
        
        /** Sets whether the ResourceFinderCallback should be invoked for every file in every archive iterated over 
         * (i.e. to ignore the {@link #searchTerm} ). By default this flag is set to false.
         * 
         * @see #getShowAll()
         * 
         * @param showAll if true, will invoke the ResourceFinderCallback for every file in every archive iterated over 
         */
        public void setShowAll(boolean showAll) {
                this.showAll = showAll;
        }
        
        /** Returns whether the ResourceFinderCallback will be invoked for every file in every archive iterated over
         * 
         * @see #setShowAll(boolean)
         * 
         * @return true if the ResourceFinderCallback will be invoked for every file in every archive iterated over, false otherwise
         */
        public boolean getShowAll() {
                return showAll;
        }
        
        /** Sets whether to ignore (some) exceptions encountered whilst processing ZipInputStreams. 
         * 
         * <p>Only EOFExceptions, ZipExceptions, IllegalArgumentExceptions and the push-back buffer 
         * IOException will be ignored if this flag is set. Ignored exceptions will still be logged.
         * 
         * <p>By default, this flag is set to false.
         *
         * @see #getIgnoreErrors()
         * 
         * @param ignoreErrors true to ignore exceptions as described above, false otherwise
         */
        public void setIgnoreErrors(boolean ignoreErrors) {
                this.ignoreErrors = ignoreErrors;
        }
        
        /** Returns true if exceptions will be ignored whilst processing ZipInputStreams
         * 
         * @see #setIgnoreErrors(boolean)
         * 
         * @return true if exceptions will be ignored whilst processing ZipInputStreams
         */
        public boolean getIgnoreErrors() {
                return ignoreErrors;
        }

        
        /** Creates a new resource finder object
         * 
         * @param searchTerm resource being searched for
         * @param matchType a MATCHTYPE_* constant denoting how the searchTerm is to be used to match against resource names
         * @param ignoreCase if true, will perform a case insensitive search 
         * @param startInputStream stream from which search begins
         * @param callback callback to be invoked on every resource that matches the search criteria 
         * 
         * @throws IOException if the start directory is invalid
         */
        public ResourceFinder(String searchTerm, int matchType, boolean ignoreCase, ZipInputStream startInputStream, ResourceFinderCallback callback) throws IOException {
                init(searchTerm, matchType, ignoreCase, callback);
                this.startInputStream = startInputStream;
        }       
        
        /** Searches and returns a list of resources matching the criteria defined
         * in the constructor
         * 
         * <p><b>TODO</b> the list returned by this object probably isn't accurate.
         * 
         * @throws IOException
         */
        public void find() throws IOException {
                this.currentArchiveDepth = -1; // yet to enumerate initial folder / stream
                if (startInputStream != null) {
                        //List<String> result = new ArrayList<String>();
                        findResourceInZip(startInputStream, "#");
                        return;
                        
                } else if (startDirectory.isFile()) {
                        //List<String> result = new ArrayList<String>();
                        File file = startDirectory;
                        String name = file.getName();
                        if (!followSymlinks && isLink(file )) {
                                // ignore symlinks
                                // System.out.println("shazbot");
                        } else if (matches(name)) {
                                FileInputStream fis = new FileInputStream(file);
                                callback.postProcess(name, file.length(), file.lastModified(), fis, null);
                                fis.close();
                                // perhaps make this another switch
                                /*
                                if (isArchive(name)) {
                                        ZipInputStream zis = new ZipInputStream(new FileInputStream(file));
                                        result.addAll(findResourceInZip(zis,  name + "#"));
                                }
                                */
                        } else if (isArchive(name)) {
                                if (showAll) {
                                        FileInputStream fis = new FileInputStream(file);
                                        callback.postProcess(name, file.length(), file.lastModified(), fis, null);
                                        fis.close();
                                }
                                ZipInputStream zis = new ZipInputStream(new FileInputStream(file));
                                zis.close();
                        } else {
                                if (showAll) {
                                        FileInputStream fis = new FileInputStream(file);
                                        callback.postProcess(name, file.length(), file.lastModified(), fis, null);
                                        fis.close();
                                }
                        }
                        return;
                } else {
                        findResourceInFolder(startDirectory, "");
                }
        }

        /** Returns true if the filename will be treated as an archive
         * 
         * @param name a filename
         * 
         * @return true if the file is an archive, false otherwise
         */
        public boolean isArchive(String name) {
                return isArchivePattern.matcher(name).matches();
        }

        /** Determines whether a file is a symbolic link. 
         * (Copied from http://www.idiom.com/~zilla/Xfiles/javasymlinks.html)
         *
         *  @param file file to test
         *  
         *  @return true if the file is a symbolic link, false otherwise
         */
        public static boolean isLink(File file) throws IOException {
                try {
                if (!file.exists()) {
                    return true;
                } else {
                            String cnnpath = file.getCanonicalPath();
                            String abspath = file.getAbsolutePath();
                            return !abspath.equals(cnnpath);
                        }
            } catch(IOException ex) {
                //System.err.println(ex);
                return true;
            }
        }

        /** Returns a list of resources within the supplied folder, subfolders,
         * and archives contained within these folders
         * 
         * @param folder the folder to search from
         * @param prefix a prefix which is included in any results returned by this
         *   method
         * 
         * @throws IOException 
         */
        public void findResourceInFolder(File folder, String prefix) throws IOException  {
                if (maxArchiveDepth!=-1 && currentArchiveDepth>=maxArchiveDepth) {
                        return;
                }
                // System.err.println("findResourceInFolder(" + prefix + "):" + currentArchiveDepth);
                currentArchiveDepth++;
                
                File[] folderContents = folder.listFiles();
                if (folderContents != null) {
                        for (File file : folderContents) {
        
                                // don't think any of these are going to work if we're calculating hashes as well.
                                // maybe it will. who knows.
                                
                                String name = file.getName();
                                // System.out.println("Filetest '" + name + "' against '" + resourceName + "' (fs=" + followSymlinks + ")");
                                if (!followSymlinks && isLink(file)) {
                                        // ignore symlinks
                                        // System.out.println("shazbot");
                                } else if (file.isDirectory() && (maxFolderDepth==-1 || currentFolderDepth+1 <= maxFolderDepth)) {
                                        currentFolderDepth++;
                                        findResourceInFolder(file, prefix + name + "/");
                                        currentFolderDepth--;
                                        
                                } else if (matches(name)) {
                                        FileInputStream fis = new FileInputStream(file);
                                        callback.postProcess(prefix + name, file.length(), file.lastModified(), fis, null);
                                        fis.close();
                                        // perhaps make this another switch
                                        if (isArchive(name)) {
                                                fis = new FileInputStream(file);
                                                ZipInputStream zis = new ZipInputStream(fis);
                                                findResourceInZip(zis, prefix + name + "#");
                                                fis.close();
                                        }
                                } else if (isArchive(name)) {
                                        if (showAll) {
                                                FileInputStream fis = new FileInputStream(file);
                                                callback.postProcess(prefix + name, file.length(), file.lastModified(), fis, null);
                                                fis.close();
                                        }
                                        FileInputStream fis = new FileInputStream(file);
                                        ZipInputStream zis = new ZipInputStream(fis);
                                        findResourceInZip(zis, prefix + name + "#");
                                        fis.close();
                                } else {
                                        if (showAll) {
                                                FileInputStream fis = new FileInputStream(file);
                                                callback.postProcess(prefix + name, file.length(), file.lastModified(), fis, null);
                                                fis.close();
                                        }
                                }
                                if (abort) { break; }
                        }
                }

                currentArchiveDepth--;
        }

        /** If ignoreErrors is true, send a message to stderr with the
         * exception message, otherwise throw an encapsulated ZipException
         * 
         * @param message message describing exception
         * @param e cause of the exception
         */
        public void ignorableException(String message, Exception e) throws ZipException {
                if (ignoreErrors) {
                        logger.error(message, e);
                } else {
                        throw (ZipException) new ZipException(message).initCause(e);
                }
        }
        
        /** Returns a list of resources within the supplied archive, 
         * and archives contained within this archive
         * 
         * @param zipInputStream the archive to search
         * @param prefix a prefix which is included in any results returned by this
         *   method. By convention, this prefix should end with a '#' to separate it
         *   from resources found within the resource.
         * 
         * @throws IOException 
         */

        public void findResourceInZip(ZipInputStream zipInputStream, String prefix) throws IOException {
                if (maxArchiveDepth!=-1 && currentArchiveDepth>=maxArchiveDepth) {
                        return;
                }
                // System.err.println("findResourceInZip(" + prefix + "):" + currentArchiveDepth);
                currentArchiveDepth++;
                
                // System.out.println("Searching in " + prefix);
                ZipEntry zipEntry = null;
                try {
                        zipEntry = zipInputStream.getNextEntry();
                } catch (EOFException oefe) {
                        ignorableException("Error retrieving first entry in zip '" + prefix.substring(0, prefix.length()-1) + "'", oefe);
                        currentArchiveDepth--;
                        return;
                } catch (ZipException ze) {
                        ignorableException("Error retrieving first entry in zip '" + prefix.substring(0, prefix.length()-1) + "'", ze);
                        currentArchiveDepth--;
                        return;
                } catch (IllegalArgumentException iae) {
                        // can occur in ZipInputStream.getUTF8String
                        ignorableException("Error retrieving first entry in zip '" + prefix.substring(0, prefix.length()-1) + "'", iae);
                        currentArchiveDepth--;
                        return;
                }
                while (zipEntry != null) {
                        String name = zipEntry.getName();
                        String shortName = name;
                        // zipEntry.isDirectory(); // write these at the end ? skip them altogether ?

                        // on unix, it's possible to get directory entries (trailing '/'s) within ZIPs; on windows this doesn't seem to happen
                        while (shortName.endsWith("/")) { shortName = shortName.substring(0, shortName.length() - 1); }
                        while (shortName.endsWith("\\")) { shortName = shortName.substring(0, shortName.length() - 1); }
                        if (shortName.indexOf('/')!=-1) { shortName = shortName.substring(shortName.lastIndexOf('/') + 1); }
                        if (shortName.indexOf('\\')!=-1) { shortName = shortName.substring(shortName.lastIndexOf('\\') + 1); }

                        // may need to do case-sensitive match
                        /* commenting this out temporarily

                        if (showVersions && name.equalsIgnoreCase("META-INF/MANIFEST.MF")) {
                                // treat this as a property file. Which is wrong, because it's got insane line breaks
                                // but good enough for retrieving version data
                                
                                Properties props = new Properties();
                                props.load(zipInputStream);
                                if (props.getProperty("Specification-Version")!=null) {
                                        // there's also an Implementation-Version, but this appears to be the same
                                        // maven2 doesn't write these entries. perhaps.
                                        // @TODO something
                                }
                        }
                        */
                        
                        InputStream inputStreamToProcess = zipInputStream;
                        
                        // might just be easier to add .reset() to ZipInputStream
                        ResourceFinderCallbackResult rfcbResult = null;
                        if (isArchive(name)) {
                                try {
                                        if (matches(shortName) || showAll) {
                                                rfcbResult = callback.preProcess(prefix + name, zipEntry.getSize(), zipEntry.getTime(), inputStreamToProcess);
                                                if (rfcbResult!=null && rfcbResult.replaceInputStream!=null) {
                                                        inputStreamToProcess = rfcbResult.replaceInputStream;
                                                }
                                                if (rfcbResult!=null && rfcbResult.abort) {
                                                        this.abort = true; break;
                                                }
                                        }
                                        ZipInputStream zis = new ZipInputStream(inputStreamToProcess);
                                        findResourceInZip(zis, prefix + name + "#");
                                        zipInputStream.closeEntry();
                                } catch (EOFException eofe) {
                                        // can trigger "java.io.EOFException: Unexpected end of ZLIB input stream" errors
                                        ignorableException("Error reading zip '" + prefix + name + "'", eofe);
                                } catch (ZipException ze) {
                                        ignorableException("Error reading zip '" + prefix + name + "'", ze);
                                }
                        }
                        if (matches(shortName) || showAll) {
                                rfcbResult = callback.postProcess(prefix + name, zipEntry.getSize(), zipEntry.getTime(), inputStreamToProcess, rfcbResult);
                                if (rfcbResult!=null && rfcbResult.abort) {
                                        this.abort = true; break;
                                }
                        }
                        
                        try {
                                zipEntry = zipInputStream.getNextEntry();
                        } catch (EOFException oefe) {
                                ignorableException("Error retrieving next entry in zip '" + prefix.substring(0, prefix.length()-1) + "'; after '"+ name + "'", oefe);
                                break;
                        } catch (ZipException ze) {
                                ignorableException("Error retrieving next entry in zip '" + prefix.substring(0, prefix.length()-1) + "'; after '"+ name + "'", ze);
                                break;
                        } catch (IllegalArgumentException iae) {
                                // can occur in ZipInputStream.getUTF8String
                                ignorableException("Error retrieving next entry in zip '" + prefix.substring(0, prefix.length()-1) + "'; after '"+ name + "'", iae);
                                break;
                        } catch (IOException ioe) {
                                // may occur after dodgy CRCs:
                                // invalid entry CRC (expected 0xab633fa2 but got 0xc30a2df7)
                                // Exception in thread "main" java.io.IOException: Push back buffer is full
                                if (ioe.getMessage().contains("Push back buffer")) {
                                        ignorableException("Error retrieving next entry in zip '" + prefix.substring(0, prefix.length()-1) + "'; after '"+ name + "'", ioe);
                                        break;
                                } else {
                                        currentArchiveDepth--;
                                        throw ioe;
                                }
                        }
                        if (abort) { break ; }
                }
                currentArchiveDepth--;
        }

        /** Returns a resource as an inputstream
         * 
         * @param resourceName a resource name, as defined by the class javadoc
         * 
         * @return the resource as an InputStream  
         * 
         * @throws FileNotFoundException the resource could not be found
         * @throws IOException the resource could not be read
         */
        public static InputStream getResourceStream(String resourceName) throws IOException {
                int pos = resourceName.indexOf("#");
                if (pos == -1) {
                        return new FileInputStream(resourceName);
                } else {
                        String filename = resourceName.substring(0, pos);
                        String component = resourceName.substring(pos + 1);
                        ZipInputStream zis = new ZipInputStream(new FileInputStream(filename));
                        return getResourceComponent(zis, component, resourceName);
                }
        }
        
        /** Private method to recursively search within an archive for a file
         * 
         * @param zipInputStream input stream to search
         * @param component resource name fragment, separated by '#' characters
         * @param fullResource full resource name (only used in exception messages)  
         * 
         * @return the input stream 
         * 
         * @throws IOException the input stream cannot be read
         */
        public static InputStream getResourceComponent(ZipInputStream zipInputStream, String component, String fullResource) throws IOException {
                int pos = component.indexOf("#");
                String filename = component;
                String subComponent = null;
                if (pos != -1) {
                        filename = component.substring(0, pos);
                        subComponent = component.substring(pos + 1);
                }
                ZipEntry zipEntry = zipInputStream.getNextEntry();
                while (zipEntry != null) {
                        if (zipEntry.getName().equals(filename)) {
                                if (subComponent == null) {
                                        return zipInputStream;
                                } else {
                                        return getResourceComponent(new ZipInputStream(zipInputStream), subComponent, fullResource); 
                                }
                        }
                        zipEntry = zipInputStream.getNextEntry();
                }
                throw new FileNotFoundException("Could not find component '" + filename + "' in '" + fullResource + "'");
        }
        
        /** Sets the maximum number of times I'm going to recursively enter a 
         * JAR/EAR/WAR/whatever.
         * 
         * <ul>
         * <li>0 = none; i.e. will just perform a directory scan.
         * <li>1..n = will search up to n directories/archives deep 
         * <li>-1 = infinite; i.e. will not perform depth checking 
         * </ul>
         * 
         * @param maxArchiveDepth maximum depth (-1=no limit, 0=will not recursive into JARs/WARs etc..)
         */
        public void setMaxArchiveDepth(long maxArchiveDepth) {
                this.maxArchiveDepth = maxArchiveDepth;
        }

        /** Sets the maximum folder depth to descend into the filesystem structure.
         * 
         * <p>This will not limit folder depth within archives, only folder depth within the filesystem 
         * 
         * <p>This setting has no effect if using the InputStream constructor.
         * 
         * <ul>
         * <li>0 = none; i.e. will just scan within the top-level folder.
         * <li>1..n = will search up to n folders deep 
         * <li>-1 = infinite; i.e. will not perform folder depth checking 
         * </ul>
         * 
         * @param maxFolderDepth maximum depth (-1=no limit, 0=will not recurse into folders)
         */
        public void setMaxFolderDepth(long maxFolderDepth) {
                this.maxFolderDepth = maxFolderDepth;
        }

        
        public static String usage() {
                return 
                  "Usage: \n" +
                  "  java " + ResourceFinder.class.getName() + " [options] searchTerm\n" +
                  "or\n" +
                  "  java " + ResourceFinder.class.getName() + " [options] -a\n" +
                  "where [options] are:\n" +
                  " -h -?     displays this helptext\n" +
                  " -f        follow symlinks\n" + 
                  " -a        show all resources found (i.e. do not use searchTerm)\n" +
                  "\n" +
                  "Search criteria:\n" +
                  " -i        case-insensitive match\n" +
                  " -sc       if present, searchTerm matches within filename (default)\n" +
                  " -ss       if present, searchTerm matches start of filename\n" +
                  " -se       if present, searchTerm matches exact filename\n" +
                  " -sr       if present, searchTerm matches filename as a regular expression\n" +
                  " -mf n     max filesystem folder depth (0 = do not descend into subfolders)\n" +
                  " -ma n     max archive depth (0 = do not descend into archives)\n" +
                  " -x        if present, will attempt to recover if errors occur reading archives\n"+
                  "             (errors sent to stderr)\n" +
                  "\n" +
                  "Action when resource found:\n" +
                  " -v        verbose; display filenames with file sizes and timestamps\n" +
                  " -vv       display MD5/SHA1 hashes of resources (NB: modifies display order)\n" +
                  " -d n      dump/display the contents of the n'th resource found\n" +
                  " -d all    dump the name and contents of all resources found\n" +
                  " -d names  dump just the names of all resources found (default)\n" +
                  " -d n1,n2... dump the name and contents of the n1'th, n2'nd etc... resources found\n" +
                  " -dm n|all as per -d, but performs manifest unmangling on resource (fixes linewraps)\n" +
                  " -dj n|all as per -d, but performs class decompiling (requires jad to be in PATH)\n" +
                  " -c text   search for text in contents of resource (uses UTF-8 encoding)\n" +
                  " -ci text  case-insensitive search for text in contents of resources\n" +
                  "\n" +
                  "* A maximum of one -d switch should be present\n" +
                  "* The -d and -c switches are mutually exclusive\n";
        }
        
        /** Command-line interface to this class
         * 
         * @param args arguments
         * 
         * @throws IOException
         */
        public static void main(String args[]) throws IOException {
                String searchTerm;
                String searchContents = null;
                String dumpResource = "";
                int     dumpType = DisplayResourceFinderCallback.DUMP_NAMES;
                List<Integer> dumpResourceList = null;
                int     argIndex = 0;
                int     matchType = MATCHTYPE_CONTAINS;
                long    maxArchiveDepth = -1;
                long    maxFolderDepth = -1;
                boolean followSymlinks = false;
                boolean verbose = false;
                boolean showHashes = false;
                boolean showAll = false;
                boolean manifests = false;
                boolean decompile = false;
                boolean ignoreCase = false;
                boolean ignoreErrors = false;
                boolean searchContentsIgnoreCase = false;
                
                if (args.length < 1) { 
                        System.out.println(usage());
                        throw new IllegalArgumentException("Expected resource search term or options");
                }
                while (argIndex < args.length && args[argIndex].startsWith("-")) {
                        if (args[argIndex].startsWith("-d")) {
                                if (args[argIndex].equals("-dm")) { manifests = true; }
                                if (args[argIndex].equals("-dj")) { decompile = true; }
                                
                            dumpResource = args[argIndex + 1];
                            if (dumpResource.equals("all")) {
                                dumpType = DisplayResourceFinderCallback.DUMP_NAMES_AND_RESOURCES;
                            } else if (dumpResource.equals("names")) {
                                dumpType = DisplayResourceFinderCallback.DUMP_NAMES;
                            } else {
                                dumpResourceList = new ArrayList<Integer>();
                                String[] resources = dumpResource.split(",");
                                for (String resource : resources) {
                                        try {
                                                dumpResourceList.add(new Integer(resource));
                                        } catch (NumberFormatException nfe) {
                                                // @TODO if it's not a number, then could use it as a resource id
                                                throw new IllegalArgumentException("Expected numeric resource id (found '" + dumpResource + "')");
                                            }
                                }
                                if (dumpResourceList.size() == 1) {
                                        dumpType = DisplayResourceFinderCallback.DUMP_RESOURCES;
                                } else {
                                        dumpType = DisplayResourceFinderCallback.DUMP_NAMES_AND_RESOURCES;
                                }
                            }
                            // 1.6 method args = Arrays.copyOfRange(args, 2, args.length);
                            argIndex += 2;
                            
                        } else if (args[argIndex].equals("-mf")) {
                                maxFolderDepth = Long.parseLong(args[argIndex + 1]);
                                argIndex += 2;
                    } else if (args[argIndex].equals("-ma")) {
                                maxArchiveDepth = Long.parseLong(args[argIndex + 1]);
                                argIndex += 2;
                        } else if (args[argIndex].equals("-v")) {
                            verbose = true;
                            argIndex ++;
                        } else if (args[argIndex].equals("-vv")) {
                                verbose = true;
                            showHashes = true;
                            argIndex ++;
                        } else if (args[argIndex].equals("-f")) {
                            followSymlinks = true;
                            argIndex ++;
                        } else if (args[argIndex].equals("-a")) {
                            showAll = true;
                            argIndex ++;
                        } else if (args[argIndex].equals("-sc")) {
                            matchType = MATCHTYPE_CONTAINS;
                            argIndex ++;
                        } else if (args[argIndex].equals("-ss")) {
                            matchType = MATCHTYPE_STARTSWITH;
                            argIndex ++;
                        } else if (args[argIndex].equals("-sr")) {
                            matchType = MATCHTYPE_REGEX;
                            argIndex ++;
                        } else if (args[argIndex].equals("-se")) {
                            matchType = MATCHTYPE_EXACT;
                            argIndex ++;
                        } else if (args[argIndex].equals("-c")) {
                            searchContents = args[argIndex + 1];
                            // System.out.println("1 searchContents is " + searchContents);
                            argIndex += 2;              
                        } else if (args[argIndex].equals("-ci")) {
                            searchContents = args[argIndex + 1];
                            searchContentsIgnoreCase = true;
                            // System.out.println("1 searchContents is " + searchContents);
                            argIndex += 2;              
                        } else if (args[argIndex].equals("-i")) {
                            ignoreCase = true;
                            argIndex ++;
                        } else if (args[argIndex].equals("-x")) {
                            ignoreErrors = true;
                            argIndex ++;
                        } else if (args[argIndex].equals("-h") || args[argIndex].equals("-?")) {
                                System.out.println(usage());
                                System.exit(0);
                        } else {
                                System.out.println(usage());
                                throw new IllegalArgumentException("Unknown switch '" + args[argIndex] + "' supplied");
                        }
                }

                if (showAll) {
                        searchTerm = "maguffin";
                } else {
                        if (args.length < argIndex + 1) {
                                System.out.println(usage());
                                throw new IllegalArgumentException("Expected resource search term");
                        }
                        searchTerm = args[argIndex++];
                }
                
                ResourceFinderCallback callback;
                if (showHashes) {
                        callback = new HashingResourceFinderCallback(ignoreErrors);
                } else {
                        callback = new DisplayResourceFinderCallback(dumpType, dumpResourceList, verbose, manifests, decompile, 
                          searchContents, searchContentsIgnoreCase);
                }
                
                ResourceFinder resourceFinder = new ResourceFinder(searchTerm, matchType, ignoreCase, new File("."), callback);
                resourceFinder.setFollowSymLinks(followSymlinks);
                resourceFinder.setShowAll(showAll);
                resourceFinder.setIgnoreErrors(ignoreErrors);
                if (maxArchiveDepth != -1) { resourceFinder.setMaxArchiveDepth(maxArchiveDepth); }
                if (maxFolderDepth != -1) { resourceFinder.setMaxFolderDepth(maxFolderDepth); }
                 
                resourceFinder.find();
                
                
        }
}