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

import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
import org.apache.felix.framework.capabilityset.SimpleFilter;
import org.apache.felix.framework.util.Util;
import org.osgi.framework.wiring.BundleRevision;

class EntryFilterEnumeration implements Enumeration
{
    private final BundleRevision m_revision;
    private final List<Enumeration> m_enumerations;
    private final List<BundleRevision> m_revisions;
    private int m_revisionIndex = 0;
    private final String m_path;
    private final List<String> m_filePattern;
    private final boolean m_recurse;
    private final boolean m_isURLValues;
    private final Set<String> m_dirEntries = new HashSet();
    private final List<Object> m_nextEntries = new ArrayList(2);

    public EntryFilterEnumeration(
        BundleRevision revision, boolean includeFragments, String path,
        String filePattern, boolean recurse, boolean isURLValues)
    {
        m_revision = revision;
        List<BundleRevision> fragments = Util.getFragments(revision.getWiring());
        if (includeFragments && !fragments.isEmpty())
        {
            m_revisions = fragments;
        }
        else
        {
            m_revisions = new ArrayList(1);
        }
        m_revisions.add(0, m_revision);
        m_enumerations = new ArrayList(m_revisions.size());
        for (int i = 0; i < m_revisions.size(); i++)
        {
            m_enumerations.add(((BundleRevisionImpl) m_revisions.get(i)).getContent() != null ?
                ((BundleRevisionImpl) m_revisions.get(i)).getContent().getEntries() : null);
        }
        m_recurse = recurse;
        m_isURLValues = isURLValues;

        // Sanity check the parameters.
        if (path == null)
        {
            throw new IllegalArgumentException("The path for findEntries() cannot be null.");
        }
        // Strip leading '/' if present.
        if ((path.length() > 0) && (path.charAt(0) == '/'))
        {
            path = path.substring(1);
        }
        // Add a '/' to the end if not present.
        if ((path.length() > 0) && (path.charAt(path.length() - 1) != '/'))
        {
            path = path + "/";
        }
        m_path = path;

        // File pattern defaults to "*" if not specified.
        filePattern = (filePattern == null) ? "*" : filePattern;

        m_filePattern = SimpleFilter.parseSubstring(filePattern);

        findNext();
    }

    public synchronized boolean hasMoreElements()
    {
        return !m_nextEntries.isEmpty();
    }

    public synchronized Object nextElement()
    {
        if (m_nextEntries.isEmpty())
        {
            throw new NoSuchElementException("No more entries.");
        }
        Object last = m_nextEntries.remove(0);
        findNext();
        return last;
    }

    private void findNext()
    {
        // This method filters the content entry enumeration, such that
        // it only displays the contents of the directory specified by
        // the path argument either recursively or not; much like using
        // "ls -R" or "ls" to list the contents of a directory, respectively.
        if (m_enumerations == null)
        {
            return;
        }
        while ((m_revisionIndex < m_enumerations.size()) && m_nextEntries.isEmpty())
        {
            while (m_enumerations.get(m_revisionIndex) != null
                && m_enumerations.get(m_revisionIndex).hasMoreElements()
                && m_nextEntries.isEmpty())
            {
                // Get the current entry to determine if it should be filtered or not.
                String entryName = (String) m_enumerations.get(m_revisionIndex).nextElement();
                // Check to see if the current entry is a descendent of the specified path.
                if (!entryName.equals(m_path) && entryName.startsWith(m_path))
                {
                    // Cached entry URL. If we are returning URLs, we use this
                    // cached URL to avoid doing multiple URL lookups from a revision
                    // when synthesizing directory URLs.
                    URL entryURL = null;

                    // If the current entry is in a subdirectory of the specified path,
                    // get the index of the slash character.
                    int dirSlashIdx = entryName.indexOf('/', m_path.length());

                    // JAR files are supposed to contain entries for directories,
                    // but not all do. So determine the directory for this entry
                    // and see if we've already seen an entry for for it. If not,
                    // synthesize an entry for it. If we are doing a recursive
                    // match, we need to synthesize each matching subdirectory
                    // of the entry.
                    if (dirSlashIdx >= 0)
                    {
                        // Start synthesizing directories for the current entry
                        // at the subdirectory after the initial path.
                        int subDirSlashIdx = dirSlashIdx;
                        String dir;
                        do
                        {
                            // Calculate the subdirectory name.
                            dir = entryName.substring(0, subDirSlashIdx + 1);
                            // If we have not seen this directory before, then record
                            // it and add it to the list of available next entries. If
                            // the original entry is actually a directory, then it will
                            // be added to next entries like normal if it matches, but if
                            // it is not a directory, its parent directory entries may be
                            // synthesized depending on the matching filter and recursion.
                            if (!m_dirEntries.contains(dir))
                            {
                                // Record the directory entry.
                                m_dirEntries.add(dir);
                                // Add the directory to the list of
                                if (SimpleFilter.compareSubstring(
                                    m_filePattern, getLastPathElement(dir)))
                                {
                                    // Add synthesized directory entry to the next
                                    // entries list in the correct form.
                                    if (m_isURLValues)
                                    {
                                        entryURL = (entryURL == null)
                                            ? ((BundleRevisionImpl) m_revisions.
                                                get(m_revisionIndex)).getEntry(entryName)
                                            : entryURL;
                                        try
                                        {
                                            m_nextEntries.add(new URL(entryURL, "/" + dir));
                                        }
                                        catch (MalformedURLException ex)
                                        {
                                        }
                                    }
                                    else
                                    {
                                        m_nextEntries.add(dir);
                                    }
                                }
                            }
                            // Now prepare to synthesize the next subdirectory
                            // if we are matching recursively.
                            subDirSlashIdx = entryName.indexOf('/', dir.length());
                        }
                        while (m_recurse && (subDirSlashIdx >= 0));
                    }

                    // Now we actually need to check if the current entry itself should
                    // be filtered or not. If we are recursive or the current entry
                    // is a child (not a grandchild) of the initial path, then we need
                    // to check if it matches the file pattern. If we've already added
                    // or synthesized the directory entry, then we can ignore it.
                    if (!m_dirEntries.contains(entryName)
                        && (m_recurse || (dirSlashIdx < 0)
                            || (dirSlashIdx == entryName.length() - 1)))
                    {
                        // See if the file pattern matches the last element of the path.
                        if (SimpleFilter.compareSubstring(
                            m_filePattern, getLastPathElement(entryName)))
                        {
                            if (m_isURLValues)
                            {
                                entryURL = (entryURL == null)
                                    ? ((BundleRevisionImpl)
                                        m_revisions.get(m_revisionIndex)).getEntry(entryName)
                                    : entryURL;
                                m_nextEntries.add(entryURL);
                            }
                            else
                            {
                                m_nextEntries.add(entryName);
                            }
                        }
                    }
                }
            }
            if (m_nextEntries.isEmpty())
            {
                m_revisionIndex++;
                // Reset directory entries, since fragments may
                // have overlapping directory entries that need
                // to be returned.
                m_dirEntries.clear();
            }
        }
    }

    private static String getLastPathElement(String entryName)
    {
        int endIdx = (entryName.charAt(entryName.length() - 1) == '/')
            ? entryName.length() - 1
            : entryName.length();
        int startIdx = (entryName.charAt(entryName.length() - 1) == '/')
            ? entryName.lastIndexOf('/', endIdx - 1) + 1
            : entryName.lastIndexOf('/', endIdx) + 1;
        return entryName.substring(startIdx, endIdx);
    }
}