/*
 * @(#)JarDiffHandler.java	1.7 03/01/23
 * 
 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package jnlp.sample.servlet;
import java.io.*;
import java.util.*;
import jnlp.sample.jardiff.*;
import javax.servlet.*;
import javax.servlet.http.*;
import jnlp.sample.util.VersionString;
import java.net.URL;
/*
 * A class that generates and caches information about JarDiff files
 *
 */
public class JarDiffHandler {
    // Default size of download buffer
    private static final int BUF_SIZE = 32 * 1024;
    
    // Default JARDiff mime type
    private static final String JARDIFF_MIMETYPE    = "application/x-java-archive-diff";
    
    /** List of all generated JARDiffs */
    private HashMap _jarDiffEntries = null;
    
    /** Reference to ServletContext and logger object */    
    private static Logger _log = null;
    private ServletContext _servletContext = null;
    private String _jarDiffMimeType = null;
    
    /* Contains information about a particular JARDiff entry */
    private static class JarDiffKey implements Comparable{	
	private String  _name;		// Name of file
	private String  _fromVersionId;	// From version
	private String  _toVersionId;	// To version
	private boolean _minimal;       // True if this is a minimal jardiff
	
	/** Constructor used to generate a query object */
	public JarDiffKey(String name, String fromVersionId, String toVersionId, boolean minimal) {	    	    
	    _name = name;
	    _fromVersionId = fromVersionId;
	    _toVersionId = toVersionId;	
	    _minimal = minimal;
	}
	
	// Query methods		
	public String getName() 		{ return _name; }
	public String getFromVersionId() 	{ return _fromVersionId; }
	public String getToVersionId() 		{ return _toVersionId; }
	public boolean isMinimal()              { return _minimal; }
	
	// Collection framework interface methods
	
	public int compareTo(Object o) {
	    // All non JarDiff entries are less
	    if (!(o instanceof JarDiffKey)) return -1;
	    JarDiffKey other = (JarDiffKey)o;    
	    
	    int n = _name.compareTo(other.getName());
	    if (n != 0) return n;
	    
	    n = _fromVersionId.compareTo(other.getFromVersionId());
	    if (n != 0) return n;

	    if (_minimal != other.isMinimal())	return -1;
	    
	    return _toVersionId.compareTo(other.getToVersionId());	    
	}
	
	public boolean equals(Object o) {
	    return compareTo(o) == 0;
	}
	
	public int hashCode() {
	    return _name.hashCode() + 
		_fromVersionId.hashCode() + 
		_toVersionId.hashCode();
	}		
    }
    
    static private class JarDiffEntry {		
	private File  	_jardiffFile;	// Location of JARDiff file
	
	public JarDiffEntry(File jarDiffFile) {		    
	    _jardiffFile = jarDiffFile;
	}
	
	public File   getJarDiffFile() 		{ return _jardiffFile; }	
    }
    
    /** Initialize JarDiff handler */
    public JarDiffHandler(ServletContext servletContext, Logger log) {	
	_jarDiffEntries = new HashMap();
	_servletContext = servletContext;
	_log = log;
	
	_jarDiffMimeType  = _servletContext.getMimeType("xyz.jardiff");
	if (_jarDiffMimeType == null) _jarDiffMimeType = JARDIFF_MIMETYPE;	         
    }    
    
    /** Returns a JarDiff for the given request */
    public synchronized DownloadResponse getJarDiffEntry(ResourceCatalog catalog, DownloadRequest dreq, JnlpResource res) {
	if (dreq.getCurrentVersionId() == null) return null;
	
	// check whether the request is from javaws 1.0/1.0.1
	// do not generate minimal jardiff if it is from 1.0/1.0.1
	boolean doJarDiffWorkAround = isJavawsVersion(dreq, "1.0 1.0.1");

	// First do a lookup to find a match
	JarDiffKey key = new JarDiffKey(res.getName(), 
					dreq.getCurrentVersionId(), 
					res.getReturnVersionId(), 
					!doJarDiffWorkAround);		
	

	JarDiffEntry entry = (JarDiffEntry)_jarDiffEntries.get(key);
	// If entry is not found, then the querty has not been made. 	
	if (entry == null) {	    	    	
	    if (_log.isInformationalLevel()) {
		_log.addInformational("servlet.log.info.jardiff.gen", 
				      res.getName(), 
				      dreq.getCurrentVersionId(), 
				      res.getReturnVersionId());
	    }
	    File f = generateJarDiff(catalog, dreq, res, doJarDiffWorkAround);	    
	    if (f == null) {
		_log.addWarning("servlet.log.warning.jardiff.failed",
				res.getName(), 
				dreq.getCurrentVersionId(), 
				res.getReturnVersionId());
	    }
	    // Store entry in table
	    entry = new JarDiffEntry(f);	    
	    _jarDiffEntries.put(key, entry);	    
	}	
	
	
	
	// Check for no JarDiff to return
	if (entry.getJarDiffFile() == null) {
	    return null;
	} else {
	    return DownloadResponse.getFileDownloadResponse(entry.getJarDiffFile(),
							    _jarDiffMimeType,
							    entry.getJarDiffFile().lastModified(),
							    res.getReturnVersionId());	
	}
    }
    

    public static boolean isJavawsVersion(DownloadRequest dreq, String version) {
	String javawsAgent = "javaws";
	String jwsVer = dreq.getHttpRequest().getHeader("User-Agent");


	// check the request is coming from javaws
	if (!jwsVer.startsWith("javaws-")) {
	    // this is the new style User-Agent string
	    // User-Agent: JNLP/1.0.1 javaws/1.4.2 (b28) J2SE/1.4.2
	    StringTokenizer st = new StringTokenizer(jwsVer);
	    while (st.hasMoreTokens()) {
		String verString = st.nextToken();
		int index = verString.indexOf(javawsAgent);
		if (index != -1) {
		    verString = verString.substring(index + javawsAgent.length() + 1);
		    return VersionString.contains(version, verString);
		}
	    }
	    return false;
	}

	// extract the version id from the download request
	int startIndex = jwsVer.indexOf("-");

	if (startIndex == -1) {
	    return false;
	}

	int endIndex = jwsVer.indexOf("/");

	if (endIndex == -1 || endIndex < startIndex) {
	    return false;
	}

	String verId = jwsVer.substring(startIndex + 1, endIndex);


	// check whether the versionString contains the versionId
	return VersionString.contains(version, verId);

    }

    /** Download resource to the given file */
    private boolean download(URL target, File file) {

	_log.addDebug("JarDiffHandler:  Doing download");	

	boolean ret = true;
	boolean delete = false;
	// use bufferedstream for better performance
	BufferedInputStream in = null;
	BufferedOutputStream out = null;
	try {
	    in = new BufferedInputStream(target.openStream());	 
	    out  = new BufferedOutputStream(new FileOutputStream(file));
	    int read = 0;
	    int totalRead = 0;
	    byte[] buf = new byte[BUF_SIZE];
	    while ((read = in.read(buf)) != -1) {
		out.write(buf, 0, read);	
		totalRead += read;	
	    }

	    _log.addDebug("total read: " + totalRead);	 
	    _log.addDebug("Wrote URL " + target.toString() + " to file " + file);
	   
	} catch(IOException ioe) {
	  
	    _log.addDebug("Got exception while downloading resource: " + ioe);
	    
	    ret = false;
	  
	    if (file != null) delete = true;
		
	} finally {
	    
	    try {
		in.close();
		in = null;
	    } catch (IOException ioe) {
		_log.addDebug("Got exception while downloading resource: " + ioe);
	    }

	    try {
		out.close();
		out = null;
	    } catch (IOException ioe) {
		_log.addDebug("Got exception while downloading resource: " + ioe);
	    }

	    if (delete) {
		file.delete();
	    }

	}
	return ret;
    }

    // fix for 4720897
    // if the jar file resides in a war file, download it to a temp dir
    // so it can be used to generate jardiff
    private String getRealPath(String path) throws IOException{

	URL fileURL =  _servletContext.getResource(path);
	
	File tempDir  = (File)_servletContext.getAttribute("javax.servlet.context.tempdir");

	// download file into temp dir
	if (fileURL != null) {
	    File newFile = File.createTempFile("temp", ".jar", tempDir);
	    if (download(fileURL, newFile)) {	       
		String filePath = newFile.getPath();
		return filePath;
	    }
	}
	return null;
    }


    private File generateJarDiff(ResourceCatalog catalog, DownloadRequest dreq, JnlpResource res, boolean doJarDiffWorkAround) {	
	boolean del_old = false;
	boolean del_new = false;

	// Lookup up file for request version
	DownloadRequest fromDreq = dreq.getFromDownloadRequest();
	try {
	    JnlpResource fromRes = catalog.lookupResource(fromDreq);
	    
	    /* Get file locations */
	    String newFilePath = _servletContext.getRealPath(res.getPath());
	    String oldFilePath = _servletContext.getRealPath(fromRes.getPath());	    	    	   
	    	    	    
	    // fix for 4720897
	    if (newFilePath == null) {
		newFilePath = getRealPath(res.getPath());
		if (newFilePath != null) del_new = true;
	    }

	    if (oldFilePath == null) {
		oldFilePath = getRealPath(fromRes.getPath());
		if (oldFilePath != null) del_old = true;
	    }
	    	  	         	   
	    if (newFilePath == null || oldFilePath == null) {
		return null;
	    }
	    
	    // Create temp. file to store JarDiff file in
	    File tempDir  = (File)_servletContext.getAttribute("javax.servlet.context.tempdir");

	    // fix for 4653036: JarDiffHandler() should use javax.servlet.context.tempdir to store the jardiff	  
	    File outputFile = File.createTempFile("jnlp", ".jardiff", tempDir);
	   	  
	    _log.addDebug("Generating Jardiff between " + oldFilePath + " and " + 
			      newFilePath + " Store in " + outputFile);
	    
	    // Generate JarDiff
	    OutputStream os = new FileOutputStream(outputFile);	   	   

	    JarDiff.createPatch(oldFilePath, newFilePath, os, !doJarDiffWorkAround);
	    os.close();
	    
	    try {

		// Check that Jardiff is smaller, or return null
		if (outputFile.length() >= (new File(newFilePath).length())) {
		    _log.addDebug("JarDiff discarded - since it is bigger");
		    return null;
		}
		
		// Check that Jardiff is smaller than the packed version of
		// the new file, if the file exists at all
		File newFilePacked = new File(newFilePath + ".pack.gz");
		if (newFilePacked.exists()) {
		    _log.addDebug("generated jardiff size: " + outputFile.length());
		    _log.addDebug("packed requesting file size: " + newFilePacked.length());
		    if (outputFile.length() >= newFilePacked.length()) {
			_log.addDebug("JarDiff discarded - packed version of requesting file is smaller");
			return null;
		    }
		}
		
		_log.addDebug("JarDiff generation succeeded");
		return outputFile;

	    } finally {		
		// delete the temporarily downloaded file
		if (del_new) {
		    new File(newFilePath).delete();
		}
		
		if (del_old) {
		    new File(oldFilePath).delete();
		}
	    }	  
	} catch(IOException ioe) {
	    _log.addDebug("Failed to genereate jardiff", ioe);
	    return null;	    	    
	} catch(ErrorResponseException ere) {
	    _log.addDebug("Failed to genereate jardiff", ere);
	    return null;	    
	}		
    }                        
}

