/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.harmony.luni.internal.net.www.protocol.jar;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.net.ContentHandler;
import java.net.ContentHandlerFactory;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.AccessController;
import java.security.Permission;
import java.security.PrivilegedAction;
import java.util.Comparator;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.TreeSet;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.zip.ZipFile;

// BEGIN android-removed
// import org.apache.harmony.kernel.vm.VM;
// END android-removed
import org.apache.harmony.luni.util.Msg;
import org.apache.harmony.luni.util.Util;

/**
 * This subclass extends <code>URLConnection</code>.
 * <p>
 * 
 * This class is responsible for connecting and retrieving resources from a Jar
 * file which can be anywhere that can be refered to by an URL.
 */
public class JarURLConnection extends java.net.JarURLConnection {

    static Hashtable<String, CacheEntry<? extends JarFile>> jarCache = new Hashtable<String, CacheEntry<?>>();

    InputStream jarInput;

    private JarFile jarFile;

    private JarEntry jarEntry;
    
    private boolean closed;

    ReferenceQueue<JarFile> cacheQueue = new ReferenceQueue<JarFile>();

    static TreeSet<LRUKey> lru = new TreeSet<LRUKey>(
            new LRUComparator<LRUKey>());

    static int Limit;

    static {
        Limit = AccessController.doPrivileged(new PrivilegedAction<Integer>() {
            public Integer run() {
                return Integer.getInteger("jar.cacheSize", 500); //$NON-NLS-1$
            }
        });
        // BEGIN android-removed
        // TODO this needs to be implemented once this is available.
        // VM.closeJars();
        // END android-removed
    }

    static final class CacheEntry<T extends JarFile> extends WeakReference<T> {
        Object key;

        CacheEntry(T jar, String key, ReferenceQueue<JarFile> queue) {
            super(jar, queue);
            this.key = key;
        }
    }

    static final class LRUKey {
        JarFile jar;

        long ts;

        LRUKey(JarFile file, long time) {
            jar = file;
            ts = time;
        }

        /**
         * @see java.lang.Object#equals(java.lang.Object)
         */
        @Override
        public boolean equals(Object obj) {
            return (obj instanceof LRUKey) &&
                (jar == ((LRUKey) obj).jar);
        }

        @Override
        public int hashCode() {
            return jar.hashCode();
        }
    }

    static final class LRUComparator<T> implements Comparator<LRUKey> {

        LRUComparator() {
        }

        /**
         * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
         */
        public int compare(LRUKey o1, LRUKey o2) {
            if ((o1).ts > (o2).ts) {
                return 1;
            }
            return (o1).ts == (o2).ts ? 0 : -1;
        }

        /**
         * @param o1
         *            an object to compare
         * @param o2
         *            an object to compare
         * @return <code>true</code> if the objects are equal,
         *         <code>false</code> otherwise.
         */
        public boolean equals(Object o1, Object o2) {
            return o1.equals(o2);
        }
    }

    /**
     * @param url
     *            the URL of the JAR
     * @throws MalformedURLException
     *             if the URL is malformed
     */
    public JarURLConnection(java.net.URL url) throws MalformedURLException {
        super(url);
    }

    /**
     * @see java.net.URLConnection#connect()
     */
    @Override
    public void connect() throws IOException {
        jarFileURLConnection = getJarFileURL().openConnection();
        findJarFile(); // ensure the file can be found
        findJarEntry(); // ensure the entry, if any, can be found
        connected = true;
    }

    /**
     * Returns the Jar file refered by this <code>URLConnection</code>
     * 
     * @return the JAR file referenced by this connection
     * 
     * @throws IOException
     *             thrown if an IO error occurs while connecting to the
     *             resource.
     */
    @Override
    public JarFile getJarFile() throws IOException {
        if (!connected) {
            connect();
        }
        return jarFile;
    }

    /**
     * Returns the Jar file refered by this <code>URLConnection</code>
     * 
     * @throws IOException
     *             if an IO error occurs while connecting to the resource.
     */
    private void findJarFile() throws IOException {
        URL jarFileURL = getJarFileURL();
        if (jarFileURL.getProtocol().equals("file")) { //$NON-NLS-1$
            String fileName = jarFileURL.getFile();
            if(!new File(Util.decode(fileName,false)).exists()){
                // KA026=JAR entry {0} not found in {1}
                throw new FileNotFoundException(Msg.getString("KA026", //$NON-NLS-1$
                        getEntryName(), fileName));
            }
            String host = jarFileURL.getHost();
            if (host != null && host.length() > 0) {
                fileName = "//" + host + fileName; //$NON-NLS-1$
            }
            jarFile = openJarFile(fileName, fileName, false);
            return;
        }

        final String externalForm = jarFileURLConnection.getURL()
                .toExternalForm();
        jarFile = AccessController
                .doPrivileged(new PrivilegedAction<JarFile>() {
                    public JarFile run() {
                        try {
                            return openJarFile(null, externalForm, false);
                        } catch (IOException e) {
                            return null;
                        }
                    }
                });
        if (jarFile != null) {
            return;
        }

        // Build a temp jar file
        final InputStream is = jarFileURLConnection.getInputStream();
        try {
            jarFile = AccessController
                    .doPrivileged(new PrivilegedAction<JarFile>() {
                        public JarFile run() {
                            try {
                                File tempJar = File.createTempFile("hyjar_", //$NON-NLS-1$
                                        ".tmp", null); //$NON-NLS-1$
                                FileOutputStream fos = new FileOutputStream(
                                        tempJar);
                                byte[] buf = new byte[4096];
                                int nbytes = 0;
                                while ((nbytes = is.read(buf)) > -1) {
                                    fos.write(buf, 0, nbytes);
                                }
                                fos.close();
                                String path = tempJar.getPath();
                                return openJarFile(path, externalForm, true);
                            } catch (IOException e) {
                                return null;
                            }
                        }
                    });
        } finally {
            is.close();
        }
        if (jarFile == null) {
            throw new IOException();
        }
    }

    JarFile openJarFile(String fileString, String key, boolean temp)
            throws IOException {

        JarFile jar = null;
        if (useCaches) {
            CacheEntry<? extends JarFile> entry;
            while ((entry = (CacheEntry<? extends JarFile>) cacheQueue.poll()) != null) {
                jarCache.remove(entry.key);
            }
            entry = jarCache.get(key);
            if (entry != null) {
                jar = entry.get();
            }
            if (jar == null && fileString != null) {
                int flags = ZipFile.OPEN_READ
                        + (temp ? ZipFile.OPEN_DELETE : 0);
                jar = new JarFile(new File(Util.decode(fileString, false)),
                        true, flags);
                jarCache
                        .put(key, new CacheEntry<JarFile>(jar, key, cacheQueue));
            } else {
                SecurityManager security = System.getSecurityManager();
                if (security != null) {
                    security.checkPermission(getPermission());
                }
                if (temp) {
                    lru.remove(new LRUKey(jar, 0));
                }
            }
        } else if (fileString != null) {
            int flags = ZipFile.OPEN_READ + (temp ? ZipFile.OPEN_DELETE : 0);
            jar = new JarFile(new File(Util.decode(fileString, false)), true,
                    flags);
        }

        if (temp) {
            lru.add(new LRUKey(jar, new Date().getTime()));
            if (lru.size() > Limit) {
                lru.remove(lru.first());
            }
        }
        return jar;
    }

    /**
     * Returns the JarEntry of the entry referenced by this
     * <code>URLConnection</code>.
     * 
     * @return java.util.jar.JarEntry the JarEntry referenced
     * 
     * @throws IOException
     *             if an IO error occurs while getting the entry
     */
    @Override
    public JarEntry getJarEntry() throws IOException {
        if (!connected) {
            connect();
        }
        return jarEntry;

    }

    /**
     * Look up the JarEntry of the entry referenced by this
     * <code>URLConnection</code>.
     */
    private void findJarEntry() throws IOException {
        if (getEntryName() == null) {
            return;
        }
        jarEntry = jarFile.getJarEntry(getEntryName());
        if (jarEntry == null) {
            throw new FileNotFoundException(getEntryName());
        }
    }

    /**
     * Creates an input stream for reading from this URL Connection.
     * 
     * @return the input stream
     * 
     * @throws IOException
     *             if an IO error occurs while connecting to the resource.
     */
    @Override
    public InputStream getInputStream() throws IOException {
        if (closed) {
            throw new IllegalStateException(Msg.getString("KA027"));
        }
        if (!connected) {
            connect();
        }
        if (jarInput != null) {
            return jarInput;
        }
        if (jarEntry == null) {
            throw new IOException(Msg.getString("K00fc")); //$NON-NLS-1$
        }
        return jarInput = new JarURLConnectionInputStream(jarFile
                .getInputStream(jarEntry), jarFile);
    }

    /**
     * Returns the content type of the resource. Test cases reveal that only if
     * the URL is refering to a Jar file, that this method returns a non-null
     * value - x-java/jar.
     * 
     * @return the content type
     */
    @Override
    public String getContentType() {
        // it could also return "x-java/jar" which jdk returns but here, we get
        // it from the URLConnection
        try {
            if (url.getFile().endsWith("!/")) { //$NON-NLS-1$
                return getJarFileURL().openConnection().getContentType();
            }
        } catch (IOException ioe) {
            // Ignore
        }
        // if there is an Jar Entry, get the content type from the name
        return guessContentTypeFromName(url.getFile());
    }

    /**
     * Returns the content length of the resource. Test cases reveal that if the
     * URL is refering to a Jar file, this method returns a content-length
     * returned by URLConnection. If not, it will return -1.
     * 
     * @return the content length
     */
    @Override
    public int getContentLength() {
        try {
            if (url.getFile().endsWith("!/")) { //$NON-NLS-1$
                return getJarFileURL().openConnection().getContentLength();
            }
        } catch (IOException e) {
            //Ignored
        }
        return -1;
    }

    /**
     * Returns the object pointed by this <code>URL</code>. If this
     * URLConnection is pointing to a Jar File (no Jar Entry), this method will
     * return a <code>JarFile</code> If there is a Jar Entry, it will return
     * the object corresponding to the Jar entry content type.
     * 
     * @return a non-null object
     * 
     * @throws IOException
     *             if an IO error occured
     * 
     * @see ContentHandler
     * @see ContentHandlerFactory
     * @see java.io.IOException
     * @see #setContentHandlerFactory(ContentHandlerFactory)
     */
    @Override
    public Object getContent() throws IOException {
        if (!connected) {
            connect();
        }
        // if there is no Jar Entry, return a JarFile
        if (jarEntry == null) {
            return jarFile;
        }
        return super.getContent();
    }

    /**
     * Returns the permission, in this case the subclass, FilePermission object
     * which represents the permission necessary for this URLConnection to
     * establish the connection.
     * 
     * @return the permission required for this URLConnection.
     * 
     * @throws IOException
     *             thrown when an IO exception occurs while creating the
     *             permission.
     */
    @Override
    public Permission getPermission() throws IOException {
        if (jarFileURLConnection != null) {
            return jarFileURLConnection.getPermission();
        }
        return getJarFileURL().openConnection().getPermission();
    }

    /**
     * Closes the cached files.
     */
    public static void closeCachedFiles() {
        Enumeration<CacheEntry<? extends JarFile>> elemEnum = jarCache
                .elements();
        while (elemEnum.hasMoreElements()) {
            try {
                ZipFile zip = elemEnum.nextElement().get();
                if (zip != null) {
                    zip.close();
                }
            } catch (IOException e) {
                // Ignored
            }
        }
    }

    private class JarURLConnectionInputStream extends FilterInputStream {
        InputStream inputStream;

        JarFile jarFile;

        protected JarURLConnectionInputStream(InputStream in, JarFile file) {
            super(in);
            inputStream = in;
            jarFile = file;
        }

        @Override
        public void close() throws IOException {
            super.close();
            if (!useCaches) {
                closed = true;
                jarFile.close();
            }
        }

        @Override
        public int read() throws IOException {
            return inputStream.read();
        }

        @Override
        public int read(byte[] buf, int off, int nbytes) throws IOException {
            return inputStream.read(buf, off, nbytes);
        }

        @Override
        public long skip(long nbytes) throws IOException {
            return inputStream.skip(nbytes);
        }
    }
}