/*===========================================================================
 * Licensed Materials - Property of IBM
 * "Restricted Materials of IBM"
 * 
 * IBM SDK, Java(tm) Technology Edition, v8
 * (C) Copyright IBM Corp. 2006, 2020. All Rights Reserved
 *
 * US Government Users Restricted Rights - Use, duplication or disclosure
 * restricted by GSA ADP Schedule Contract with IBM Corp.
 *===========================================================================
 */
/*
 * Copyright (c) 2006, 2017, Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *
 * Neither the name of Oracle nor the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 */

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*");

        // 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;
        }
    }
}
