/*
    * Created on 19-Dec-2004
    */
   package uk.ac.roe.antigen.ant;
   
   import java.io.BufferedInputStream;
   import java.io.File;
   import java.io.FileOutputStream;
   import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.BufferedOutputStream;
  import java.net.JarURLConnection;
  import java.net.URL;
  import java.util.Enumeration;
  import java.util.jar.JarEntry;
  import java.util.jar.JarFile;
  import java.util.logging.Logger;
  
  import uk.ac.roe.antigen.utils.CopyableFile;
  
  
  /***
   * Grabs a directory, or a zip file, and installs it in the temp directory for
   * processing
   * 
   * @author jdt
   *  
   */
  public class BuildGrabber {
      /***
       * Logger for this class
       */
      private static final Logger logger = Logger.getLogger(BuildGrabber.class.getName());
  
  
  	private CopyableFile tmpDir;
  
  	public static void main(String[] args) throws Exception {
  		BuildGrabber grabber = new BuildGrabber();
  		try {
  			CopyableFile tmp = grabber.tmpDir;
  			logger.fine("Temporary directory: " + tmp);
  			//File testDir = new File("C:/Java/ag-integration-work");
  			URL jarUrl = new URL(
  					"file:///C:/Documents and Settings/jdt/.maven/repository/org.astrogrid/wars/astrogrid-portal-0.7-b015p.war");
  			//File copiedDir = grabber.grab(jarUrl);
  			File copiedDir = grabber.grab("/foo");
  			logger.fine("Copied dir was " + copiedDir);
  			Thread.sleep(30000);
  		} finally {
  			System.out.println("Deleted? " + grabber.deleteTmp());
  		}
  	}
  
  	/***
  	 * Source files are supplied as a known directory
  	 * 
  	 * @param dir
  	 * @throws IOException
  	 * @return the tmp directory holding the files
  	 */
  	public CopyableFile grab(File dir) throws IOException {
  		new CopyableFile(dir).copyTo(tmpDir);
  		return tmpDir;
  	}
  
  	/***
  	 * Grabs contents of a jar file from a URL and unzip to a temp directory
  	 * 
  	 * @param url
  	 *            of jar file
  	 * @return the tmp directory holding the files
  	 * @throws IOException
  	 */
  	public CopyableFile grab(URL url) throws IOException {
  		String simpleUrl = url.toExternalForm();
  		logger.fine("Grabbing from " + simpleUrl);
  		JarURLConnection jarUrl = (JarURLConnection) new URL("jar:" + simpleUrl
  				+ "!/").openConnection();
  		logger.fine("Opening connection to " + jarUrl);
  		JarFile jarFile = jarUrl.getJarFile();
  		return grab(jarFile);
  	}
  
  	/***
  	 * Grab the contents of a jar file and unzip to a temp directory
  	 * 
  	 * @param jar
  	 *            the jar file
  	 * @return the tmp directory holding the files
  	 * @throws IOException
  	 * @TODO factor this out into separate class
  	 */
  	public CopyableFile grab(JarFile jar) throws IOException {
  		Enumeration entries = jar.entries();
  		while (entries.hasMoreElements()) {
  			JarEntry entry = (JarEntry) entries.nextElement();
  			logger.fine("Entry " + entry);
 
 			File copiedFileEntry = new File(tmpDir, entry.getName());
 			logger.fine("Copying to " + copiedFileEntry.getAbsolutePath());
 
 			if (entry.isDirectory()) {
 				copiedFileEntry.mkdirs();
 			} else {
 				InputStream is = new BufferedInputStream(jar
 						.getInputStream(entry));
 				copiedFileEntry.createNewFile();
 				FileOutputStream os = new FileOutputStream(copiedFileEntry);
 
 				copyStreams(is, os);
 			}
 
 		}
 		return tmpDir;
 	}
 
 	private void copyStreams(InputStream in, OutputStream out)
 			throws IOException {
 		int data = -1;
 		while ((data = in.read()) != -1) {
 			out.write(data);
 		}
 		out.close();
 
 		in.close();
 	}
 
 	/***
 	 * Grabs stuff off the classpath and stick it in the temp directory
 	 * 
 	 * @param path
 	 *            the path off the classpath to the jar
 	 * @return the temp directory in which the grabbed stuff has been stuck
 	 * @throws IOException
 	 */
 	public CopyableFile grab(String path) throws IOException {
         // Since this has been reimplemented, it only deals with 
         // paths that are absolute off the classpath, so any initial
         // slash must be dropped.
         if (path.startsWith("/")) {
             path = path.substring(1);
         }
 		File tmpJarFile = File.createTempFile("build", ".jar");
 		tmpJarFile.deleteOnExit();
                 JarFile installSource = new JarFile(System.getProperty("java.class.path"));
                 logger.fine("path: "+path);
                 File antBuildJar = unzipFile(path,installSource, tmpDir, false);
 
 		JarFile jar = new JarFile(antBuildJar);
                 unzipFile(null,jar,tmpDir,true);
 
 		return tmpDir;
 
 	}
 
     /***
      * Unzips either one file specified by fullPathFileName or all files (if fullPathFileName is null) from srcJar to destDir
      * @param fullPathFileName
      * @param srcJar
      * @param destDir
      * @return if fullPathFileName is not null then returns the unzipped file, otherwise returns null
      */
     private File unzipFile(String fullPathFileName, JarFile srcJar, File destDir, boolean useFullPath) {
        int BUFFER = 16384;
        BufferedOutputStream dest = null;
        BufferedInputStream is = null;
        JarEntry entry;
        String newFullPathFileName = null;
        Enumeration e = srcJar.entries();
         try {
            while(e.hasMoreElements()) {
                entry = (JarEntry) e.nextElement();
                if (fullPathFileName != null && !(entry.getName().equals(fullPathFileName) )) {
                    continue;
                }
 
                logger.fine("Extracting: " +entry);
                is = new BufferedInputStream(srcJar.getInputStream(entry));
                 int count;
                 byte data[] = new byte[BUFFER];
                int lastIndexOfSlashPlusOne = entry.getName().lastIndexOf('/')+1;
                String path = null;
                String fileName = null;
                if (lastIndexOfSlashPlusOne == 0) {
                    path = "";
                } else {
                    path = entry.getName().substring(0,lastIndexOfSlashPlusOne);
                    String sep = File.separator;
                    if (sep.equals("//")) {
                        sep = "////";
                    }
                    path = path.replaceAll("/",sep);
                }
                fileName = entry.getName().substring(lastIndexOfSlashPlusOne);
                String newEntryName = destDir.getAbsolutePath()+File.separator+path+fileName;
                if (!useFullPath) {
                    newEntryName = destDir.getAbsolutePath()+File.separator+fileName;
                }
                if (entry.isDirectory()) {
                    File entryFile = new File(newEntryName);
                    if (!entryFile.exists()) {
                        entryFile.mkdirs();
                    }
                    continue;
                }
                newFullPathFileName = newEntryName;
 
                 FileOutputStream fos = new FileOutputStream(newFullPathFileName);
                 dest = new
                   BufferedOutputStream(fos, BUFFER);
                 while ((count = is.read(data, 0, BUFFER)) != -1) {
                    dest.write(data, 0, count);
                 }
                 dest.flush();
                 dest.close();
                 is.close();
                if (fullPathFileName != null) {
                     return new File(newFullPathFileName);
                 }
              }
          } catch(Exception ex) {
             logger.warning(ex.getMessage());
             ex.printStackTrace();
          }
 
         return null;
     }
 
     /***
 	 * On the off chance that the system doesn't delete it, you can try to
 	 * delete it yourself
 	 * 
 	 * @return true or false depending on success
 	 */
 	public boolean deleteTmp() {
 
 		return tmpDir.recursivelyDelete();
 	}
 
 	/***
 	 * Set up temp directories etc
 	 * 
 	 * @throws IOException
 	 *  
 	 */
 	public BuildGrabber() throws IOException {
 		String systemTemp = System.getProperty("java.io.tmpdir");
 		logger.fine("System Temp Dir " + systemTemp);
 
 		tmpDir = new CopyableFile(File.createTempFile("antigen", "", new File(
 				systemTemp)));
         logger.info("Build Dir " + tmpDir);
 		//Delete any existing file
 		tmpDir.delete();
 		tmpDir.mkdirs();
 		tmpDir.deleteOnExit();
 	}
     /***
      * Set up temp directories etc
      * User-supplied tmpdirectory
      * 
      * @throws IOException
      *  
      */
     public BuildGrabber(File dir) throws IOException {
         tmpDir = new CopyableFile(dir);
         logger.info("Build Dir " + tmpDir);
     }
 }