/*
    * 
    * 
    */
   
   package earutils.expander;
   
   import java.io.*;
   import java.util.*;
  import java.util.zip.*;
  
  /***
   * 
   * @author Sean C. Sullivan
   * 
   */
  public class Expander
  {
  	protected Set expansionExtensions = new java.util.HashSet();
  	protected String outputPath;
  	protected Set listeners = new java.util.HashSet();
  
  	public Expander()
  	{
  	}
  
  	public void addExpanderListener(ExpanderListener l)
  	{
  		listeners.add(l);
  	}
  	
  	public void removeExpanderListener(ExpanderListener l)
  	{
  		if (listeners.contains(l))
  		{
  			listeners.remove(l);
  		}
  	}
  
  	protected void fireExpansionStartedEvent(String archiveName)
  	{
  		Iterator iter = listeners.iterator();
  		while (iter.hasNext())
  		{
  			ExpanderListener l = (ExpanderListener) iter.next();
  			l.expansionStarted(archiveName);
  		}
  	}
  	
  	protected void fireExpansionFinishedEvent(String archiveName, boolean success, long duration)
  	{
  		Iterator iter = listeners.iterator();
  		while (iter.hasNext())
  		{
  			ExpanderListener l = (ExpanderListener) iter.next();
  			l.expansionFinished(archiveName, success, duration);
  		}
  	}
  
  	protected void fireEntrySkippedEvent(String entryName)
  	{
  		Iterator iter = listeners.iterator();
  		while (iter.hasNext())
  		{
  			ExpanderListener l = (ExpanderListener) iter.next();
  			l.entrySkipped(entryName);
  		}
  	}
  	
  	protected void fireFileCreatedEvent(String file)
  	{
  		Iterator iter = listeners.iterator();
  		while (iter.hasNext())
  		{
  			ExpanderListener l = (ExpanderListener) iter.next();
  			l.fileCreated(file);
  		}
  	
  	}
  	
  	public void setExpansionExtensions(Set s)
  	{
  		this.expansionExtensions = s;
  	}
  
  	public Set getExpansionExtensions()
  	{
  		return this.expansionExtensions;
  	}
  
  	public void setOutputPath(String path)
  	{
  		outputPath = path;
  	}
  
  	public String getOutputPath()
  	{
  		return outputPath;
  	}
 
 	static private void mkdirs(String path)
 	{
 		java.io.File f = new File(path);
 		f.mkdirs();
 	}
 
 	public void expand(String earFilename) throws java.io.IOException
 	{
 		if (earFilename == null)
 		{
 			throw new NullPointerException("earFilename parameter");
 		}
 		
 		File f = new File(earFilename);
 		
 		validateEARFile(f);
 		
 		InputStream in = null;
 		
 		in = new FileInputStream(f);
 		
 		try
 		{
 			expand(in, f.getName());
 		}
 		finally
 		{
 			if (in != null)
 			{
 				in.close();
 			}
 		}
 	}
 
 	protected void validateOutputPath()
 	{
 		if ( (getOutputPath() == null)
 			 || (getOutputPath().length() == 0) )
 		{
 			throw new RuntimeException("Output path is not set");
 		}
 		
 		File outputDir = new File(getOutputPath());
 		
 		if ( ! outputDir.exists())
 		{
 			throw new RuntimeException("Directory does not exist: "
 					+ outputDir.getName());
 		}
 		if ( ! outputDir.isDirectory())
 		{
 			throw new RuntimeException("Not a directory: "
 					+ outputDir.getName());
 		}
 	}
 	
 	protected void validateEARFile(File earFile)
 	{
 		if ( ! earFile.exists())
 		{
 			throw new RuntimeException("File does not exist: "
 						+ earFile.getName());
 		}
 		
 		if ( ! earFile.isFile())
 		{
 			throw new RuntimeException("Not a valid file: "
 					+ earFile.getName());
 		}
 		
 		if ( ! earFile.canRead())
 		{
 			throw new RuntimeException("Cannot read file: "
 					+ earFile.getName());
 		}
 	}
 	
 	public void expand(InputStream in, String name) throws java.io.IOException
 	{
 		boolean success = false;
 
 		long start = System.currentTimeMillis();
 
 		try
 		{
 			validateOutputPath();
 			
 			String path = getOutputPath() + File.separator + name;
 			
 			doExpand(in, name, path);
 			success = true;
 		}
 		finally
 		{
 			long end = System.currentTimeMillis();
 			long duration = end - start;
 			fireExpansionFinishedEvent(name, success, duration);
 		}
 	}
 
 	/***
 	 * 
 	 * @param in
 	 * @param name
 	 * @param path
 	 * @throws java.io.IOException
 	 * 
 	 * The caller is responsible for closing the InputStream
 	 * 
 	 */
 	protected void doExpand(InputStream in, String name, String path)
 			throws java.io.IOException
 	{
 		mkdirs(path);
 
 		ZipInputStream zis = new ZipInputStream(in);
 
 		ZipEntry entry = zis.getNextEntry();
 
 		while (entry != null)
 		{
 			processZipEntry(entry, zis, path);
 			zis.closeEntry();
 			entry = zis.getNextEntry();
 		}
 		
 	}
 
 	protected boolean ignoreThisEntry(String entryName)
 	{
 		if ("CVS".equals(entryName))
 		{
 			return true;
 		}
 		else if (entryName.indexOf("CVS/") != -1)
 		{
 			return true;
 		}
 		else
 		{
 			return false;
 		}
 	}
 
 	protected void processZipEntry(ZipEntry zipEntry, 
 						InputStream is,
 						String path) throws IOException
 	{
 		mkdirs(path);
 		String entryName = zipEntry.getName();
 
 		if (ignoreThisEntry(entryName))
 		{
 			fireEntrySkippedEvent(entryName);
 		}
 		else if (zipEntry.isDirectory())
 		{
 			mkdirs(path + File.separator + entryName);
 		}
 		else if (shouldExpand(entryName))
 		{
 			doExpand(is, entryName, path + File.separator + entryName);
 		}
 		else
 		{
 			String filename;
 			String filepath;
 			int index = entryName.lastIndexOf('/');
 			if (index != -1)
 			{
 				filename = entryName.substring(index + 1, entryName.length());
 				filepath = path + File.separator + entryName.substring(0, index);
 			}
 			else
 			{
 				filename = entryName;
 				filepath = path;
 			}
 			
 			createFile(filename, is, filepath);
 		}
 	}
 
 	protected void createFile(String name, InputStream in, String path) throws IOException 
 	{
 		path = path.replace('/', File.separatorChar);
 		mkdirs(path);
 		FileOutputStream fos = null;
 		
 		String outputFilename = path + File.separator + name;
 		fos = new FileOutputStream(outputFilename);
 		
 		byte[] buf = new byte[4096];
 		int n = -1;
 		while ( ( n = in.read(buf) ) != -1)
 		{
 			fos.write(buf, 0, n);
 		}
 		fos.flush();
 		fos.close();
 		
 		fireFileCreatedEvent(outputFilename);
 	}
 	
 	protected boolean shouldExpand(String name)
 	{
 		boolean result = false;
 
 		if (name == null)
 		{
 			result = false;
 		}
 		else
 		{
 			result = false;
 			String lowercaseName = name.toLowerCase();
 			Iterator iter = getExpansionExtensions().iterator();
 			while (iter.hasNext())
 			{
 				String ext = (String) iter.next();
 				if (lowercaseName.endsWith(ext))
 				{
 					result = true;
 					break;
 				}
 			}
 		}
 
 		return result;
 
 	}
 	
 	public String toString()
 	{
 		StringBuffer sb = new StringBuffer();
 		sb.append("outputPath='" + getOutputPath() + "', ");
 		sb.append("expansionExtensions=");
 		sb.append(String.valueOf(this.getExpansionExtensions()));
 		return sb.toString();
 	}
 
 }