/*
 * 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.felix.framework.util;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 * This class implements a factory for creating weak zip files, which behave
 * mostly like a ZipFile, but can be weakly closed to limit the number of
 * open files.
 */
public class WeakZipFileFactory
{
    private static final int WEAKLY_CLOSED = 0;
    private static final int OPEN = 1;
    private static final int CLOSED = 2;

    private static final SecureAction m_secureAction = new SecureAction();

    private final List<WeakZipFile> m_zipFiles = new ArrayList<WeakZipFile>();
    private final List<WeakZipFile> m_openFiles = new ArrayList<WeakZipFile>();
    private final Lock m_globalMutex = new ReentrantLock();
    private final int m_limit;

    /**
     * Constructs a weak zip file factory with the specified file limit. A limit
     * of zero signifies no limit.
     * @param limit maximum number of open zip files at any given time.
     */
    public WeakZipFileFactory(int limit)
    {
        if (limit < 0)
        {
            throw new IllegalArgumentException("Limit must be non-negative.");
        }
        m_limit = limit;
    }

    /**
     * Factory method used to create weak zip files.
     * @param file the target zip file.
     * @return the created weak zip file.
     * @throws IOException if the zip file could not be opened.
     */
    public WeakZipFile create(File file) throws IOException
    {
        WeakZipFile wzf = new WeakZipFile(file);

        if (m_limit > 0)
        {
            m_globalMutex.lock();

            try
            {
                m_zipFiles.add(wzf);
                m_openFiles.add(wzf);
                if (m_openFiles.size() > m_limit)
                {
                    WeakZipFile candidate = m_openFiles.get(0);
                    for (WeakZipFile tmp : m_openFiles)
                    {
                        if (candidate.m_timestamp > tmp.m_timestamp)
                        {
                            candidate = tmp;
                        }
                    }
                    candidate._closeWeakly();
                }
            }
            finally
            {
                m_globalMutex.unlock();
            }
        }

        return wzf;
    }

    /**
     * Only used for testing.
     * @return unclosed weak zip files.
     **/
    List<WeakZipFile> getZipZiles()
    {
        m_globalMutex.lock();

        try
        {
            return m_zipFiles;
        }
        finally
        {
            m_globalMutex.unlock();
        }
    }

    /**
     * Only used for testing.
     * @return open weak zip files.
     **/
    List<WeakZipFile> getOpenZipZiles()
    {
        m_globalMutex.lock();

        try
        {
            return m_openFiles;
        }
        finally
        {
            m_globalMutex.unlock();
        }
    }

    /**
     * This class wraps a ZipFile to making it possible to weakly close it;
     * this means the underlying zip file will be automatically reopened on demand
     * if anyone tries to use it.
     */
    public class WeakZipFile
    {
        private final File m_file;
        private final Lock m_localMutex = new ReentrantLock(false);
        private volatile ZipFile m_zipFile;
        private volatile int m_status = OPEN;
        private volatile long m_timestamp;
        private volatile SoftReference<LinkedHashMap<String, ZipEntry>> m_entries;

        /**
         * Constructor is private since instances need to be centrally
         * managed.
         * @param file the target zip file.
         * @throws IOException if the zip file could not be opened.
         */
        private WeakZipFile(File file) throws IOException
        {
            m_file = file;
            m_zipFile = m_secureAction.openZipFile(m_file);
            m_timestamp = System.currentTimeMillis();
        }

        /**
         * Returns the specified entry from the zip file.
         * @param name the name of the entry to return.
         * @return the zip entry associated with the specified name or null
         *         if it does not exist.
         */
        public ZipEntry getEntry(String name)
        {
            ensureZipFileIsOpen();

            try
            {
                LinkedHashMap<String, ZipEntry> entries = getEntries(false);
                ZipEntry ze;
                if (entries != null)
                {
                    ze = entries.get(name);
                    if (ze == null)
                    {
                        ze = entries.get(name + "/");
                    }
                }
                else
                {
                    ze = m_zipFile.getEntry(name);
                }

                if ((ze != null) && (ze.getSize() == 0) && !ze.isDirectory())
                {
                    //The attempts to fix an apparent bug in the JVM in versions
                    // 1.4.2 and lower where directory entries in ZIP/JAR files are
                    // not correctly identified.
                    ZipEntry dirEntry = m_zipFile.getEntry(name + '/');
                    if (dirEntry != null)
                    {
                        ze = dirEntry;
                    }
                }
                return ze;
            }
            finally
            {
                if (m_limit > 0)
                {
                    m_localMutex.unlock();
                }
            }
        }

        /**
         * Returns an enumeration of zip entries from the zip file.
         * @return an enumeration of zip entries.
         */
        public Enumeration<ZipEntry> entries()
        {
            ensureZipFileIsOpen();

            try
            {
                LinkedHashMap<String, ZipEntry> entries = getEntries(true);
                return Collections.enumeration(entries.values());
            }
            finally
            {
                if (m_limit > 0)
                {
                    m_localMutex.unlock();
                }
            }
        }

        public Enumeration<String> names()
        {
            ensureZipFileIsOpen();

            try
            {
                LinkedHashMap<String, ZipEntry> entries = getEntries(true);
                return Collections.enumeration(entries.keySet());
            }
            finally
            {
                if (m_limit > 0)
                {
                    m_localMutex.unlock();
                }
            }
        }

        private LinkedHashMap<String, ZipEntry> getEntries(boolean create)
        {
            LinkedHashMap<String, ZipEntry> entries = null;
            if (m_entries != null)
            {
                entries = m_entries.get();
            }
            if (entries == null && create)
            {
                synchronized (m_zipFile)
                {
                    if (m_entries != null)
                    {
                        entries = m_entries.get();
                    }
                    if (entries == null)
                    {
                        // We need to suck in all of the entries since the zip
                        // file may get weakly closed during iteration. Technically,
                        // this may not be 100% correct either since if the zip file
                        // gets weakly closed and reopened, then the zip entries
                        // will be from a different zip file. It is not clear if this
                        // will cause any issues.
                        Enumeration<? extends ZipEntry> e = m_zipFile.entries();
                        entries = new LinkedHashMap<String, ZipEntry>();
                        while (e.hasMoreElements())
                        {
                            ZipEntry entry = e.nextElement();
                            entries.put(entry.getName(), entry);
                        }
                        m_entries = new SoftReference<LinkedHashMap<String, ZipEntry>>(entries);
                    }
                }
            }
            return entries;
        }

        /**
         * Returns an input stream for the specified zip entry.
         * @param ze the zip entry whose input stream is to be retrieved.
         * @return an input stream to the zip entry.
         * @throws IOException if the input stream cannot be opened.
         */
        public InputStream getInputStream(ZipEntry ze) throws IOException
        {
            ensureZipFileIsOpen();

            try
            {
                InputStream is = m_zipFile.getInputStream(ze);
                return m_limit == 0 ? is : new WeakZipInputStream(ze.getName(), is);
            }
            finally
            {
                if (m_limit > 0)
                {
                    m_localMutex.unlock();
                }
            }
        }

        /**
         * Weakly closes the zip file, which means that it will be reopened
         * if anyone tries to use it again.
         */
        void closeWeakly()
        {
            m_globalMutex.lock();

            try
            {
                _closeWeakly();
            }
            finally
            {
                m_globalMutex.unlock();
            }
        }

        /**
         * This method is used internally to weakly close a zip file. It should
         * only be called when already holding the global lock, otherwise use
         * closeWeakly().
         */
        private void _closeWeakly()
        {
            m_localMutex.lock();

            try
            {
                if (m_status == OPEN)
                {
                    try
                    {
                        m_status = WEAKLY_CLOSED;
                        if (m_zipFile != null)
                        {
                            m_zipFile.close();
                            m_zipFile = null;
                        }
                        m_openFiles.remove(this);
                    }
                    catch (IOException ex)
                    {
                        __close();
                    }
                }
            }
            finally
            {
                m_localMutex.unlock();
            }
        }

        /**
         * This method permanently closes the zip file.
         * @throws IOException if any error occurs while trying to close the
         *         zip file.
         */
        public void close() throws IOException
        {
            if (m_limit > 0)
            {
                m_globalMutex.lock();
                m_localMutex.lock();
            }

            try
            {
                ZipFile tmp = m_zipFile;
                __close();
                if (tmp != null)
                {
                    tmp.close();
                }
            }
            finally
            {
                if (m_limit > 0)
                {
                    m_localMutex.unlock();
                    m_globalMutex.unlock();
                }
            }
        }

        /**
         * This internal method is used to clear the zip file from the data
         * structures and reset its state. It should only be called when
         * holding the global and local mutexes.
         */
        private void __close()
        {
            m_status = CLOSED;
            m_zipFile = null;
            m_zipFiles.remove(this);
            m_openFiles.remove(this);
        }

        /**
         * This method ensures that the zip file associated with this
         * weak zip file instance is actually open and acquires the
         * local weak zip file mutex. If the underlying zip file is closed,
         * then the local mutex is released and an IllegalStateException is
         * thrown. If the zip file is weakly closed, then it is reopened.
         * If the zip file is already opened, then no additional action is
         * necessary. If this method does not throw an exception, then
         * the end result is the zip file member field is non-null and the
         * local mutex has been acquired.
         */
        private void ensureZipFileIsOpen()
        {
            if (m_limit == 0)
            {
                return;
            }

            // Get mutex for zip file.
            m_localMutex.lock();

            // If zip file is closed, then just return null.
            if (m_status == CLOSED)
            {
                m_localMutex.unlock();
                throw new IllegalStateException("Zip file is closed: " + m_file);
            }

            // If zip file is weakly closed, we need to reopen it,
            // but we have to release the zip mutex to acquire the
            // global mutex, then reacquire the zip mutex. This
            // ensures that the global mutex is always acquired
            // before any local mutex to avoid deadlocks.
            IOException cause = null;
            if (m_status == WEAKLY_CLOSED)
            {
                m_localMutex.unlock();

                m_globalMutex.lock();

                m_localMutex.lock();

                // Double check status since it may have changed.
                if (m_status == CLOSED)
                {
                    m_localMutex.unlock();
                    m_globalMutex.unlock();
                    throw new IllegalStateException("Zip file is closed: " + m_file);
                }
                else if (m_status == WEAKLY_CLOSED)
                {
                    try
                    {
                        __reopenZipFile();
                    }
                    catch (IOException ex)
                    {
                        cause = ex;
                    }
                }

                // Release the global mutex, since it should no longer be necessary.
                m_globalMutex.unlock();
            }

            // It is possible that reopening the zip file failed, so we check
            // for that case and throw an exception.
            if (m_zipFile == null)
            {
                m_localMutex.unlock();
                IllegalStateException ise =
                    new IllegalStateException("Zip file is closed: " + m_file);
                if (cause != null)
                {
                    ise.initCause(cause);
                }
                throw ise;
            }
        }

        /**
         * Thie internal method is used to reopen a weakly closed zip file.
         * It makes a best effort, but may fail and leave the zip file member
         * field null. Any failure reopening a zip file results in it being
         * permanently closed. This method should only be invoked when holding
         * the global and local mutexes.
         */
        private void __reopenZipFile() throws IOException
        {
            if (m_status == WEAKLY_CLOSED)
            {
                try
                {
                    m_zipFile = m_secureAction.openZipFile(m_file);
                    m_status = OPEN;
                    m_timestamp = System.currentTimeMillis();
                }
                catch (IOException ex)
                {
                    __close();
                    throw ex;
                }

                if (m_zipFile != null)
                {
                    m_openFiles.add(this);
                    if (m_openFiles.size() > m_limit)
                    {
                        WeakZipFile candidate = m_openFiles.get(0);
                        for (WeakZipFile tmp : m_openFiles)
                        {
                            if (candidate.m_timestamp > tmp.m_timestamp)
                            {
                                candidate = tmp;
                            }
                        }
                        candidate._closeWeakly();
                    }
                }
            }
        }

        /**
         * This is an InputStream wrapper that will properly reopen the underlying
         * zip file if it is weakly closed and create the underlying input stream.
         */
        class WeakZipInputStream extends InputStream
        {
            private final String m_entryName;
            private volatile InputStream m_is;
            private volatile int m_currentPos = 0;
            private volatile ZipFile m_zipFileSnapshot;

            WeakZipInputStream(String entryName, InputStream is)
            {
                m_entryName = entryName;
                m_is = is;
                m_zipFileSnapshot = m_zipFile;
            }

            /**
             * This internal method ensures that the zip file is open and that
             * the underlying input stream is valid. Upon successful completion,
             * the underlying input stream will be valid and the local mutex
             * will be held.
             * @throws IOException if the was an error handling the input stream.
             */
            private void ensureInputStreamIsValid() throws IOException
            {
                if (m_limit == 0)
                {
                    return;
                }

                ensureZipFileIsOpen();

                // If the underlying zip file changed, then we need
                // to get the input stream again.
                if (m_zipFileSnapshot != m_zipFile)
                {
                    m_zipFileSnapshot = m_zipFile;

                    if (m_is != null)
                    {
                        try
                        {
                            m_is.close();
                        }
                        catch (Exception ex)
                        {
                            // Not much we can do.
                        }
                    }
                    try
                    {
                        m_is = m_zipFile.getInputStream(m_zipFile.getEntry(m_entryName));
                        m_is.skip(m_currentPos);
                    }
                    catch (IOException ex)
                    {
                        if (m_limit > 0)
                        {
                            m_localMutex.unlock();
                        }
                        throw ex;
                    }
                }
            }

            @Override
            public int available() throws IOException
            {
                ensureInputStreamIsValid();
                try
                {
                    return m_is.available();
                }
                finally
                {
                    if (m_limit > 0)
                    {
                        m_localMutex.unlock();
                    }
                }
            }

            @Override
            public void close() throws IOException
            {
                ensureInputStreamIsValid();
                try
                {
                    InputStream is = m_is;
                    m_is = null;
                    if (is != null)
                    {
                        is.close();
                    }
                }
                finally
                {
                    if (m_limit > 0)
                    {
                        m_localMutex.unlock();
                    }
                }
            }

            public int read() throws IOException
            {
                ensureInputStreamIsValid();
                try
                {
                    int len = m_is.read();
                    if (len > 0)
                    {
                        m_currentPos++;
                    }
                    return len;
                }
                finally
                {
                    if (m_limit > 0)
                    {
                        m_localMutex.unlock();
                    }
                }
            }

            @Override
            public int read(byte[] bytes) throws IOException
            {
                ensureInputStreamIsValid();
                try
                {
                    int len = m_is.read(bytes);
                    if (len > 0)
                    {
                        m_currentPos += len;
                    }
                    return len;
                }
                finally
                {
                    if (m_limit > 0)
                    {
                        m_localMutex.unlock();
                    }
                }
            }

            @Override
            public int read(byte[] bytes, int i, int i1) throws IOException
            {
                ensureInputStreamIsValid();
                try
                {
                    int len = m_is.read(bytes, i, i1);
                    if (len > 0)
                    {
                        m_currentPos += len;
                    }
                    return len;
                }
                finally
                {
                    if (m_limit > 0)
                    {
                        m_localMutex.unlock();
                    }
                }
            }

            @Override
            public long skip(long l) throws IOException
            {
                ensureInputStreamIsValid();
                try
                {
                    long len = m_is.skip(l);
                    if (len > 0)
                    {
                        m_currentPos += len;
                    }
                    return len;
                }
                finally
                {
                    if (m_limit > 0)
                    {
                        m_localMutex.unlock();
                    }
                }
            }
        }
    }
}