/*
 *  Copyright (c) 2003-2010 The Regents of the University of California.
 *  All rights reserved.
 *  Permission is hereby granted, without written agreement and without
 *  license or royalty fees, to use, copy, modify, and distribute this
 *  software and its documentation for any purpose, provided that the above
 *  copyright notice and the following two paragraphs appear in all copies
 *  of this software.
 *  IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 *  FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 *  ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 *  THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *  THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 *  PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 *  CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 *  ENHANCEMENTS, OR MODIFICATIONS.
 *  PT_COPYRIGHT_VERSION_2
 *  COPYRIGHTENDKEY
 */
package org.kepler.kar;

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.jar.Attributes;
import java.util.jar.Attributes.Name;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.kepler.build.modules.Module;
import org.kepler.build.util.Version;
import org.kepler.configuration.ConfigurationManager;
import org.kepler.configuration.ConfigurationManagerException;
import org.kepler.configuration.ConfigurationProperty;
import org.kepler.configuration.NamespaceException;
import org.kepler.objectmanager.cache.CacheException;
import org.kepler.objectmanager.cache.CacheManager;
import org.kepler.objectmanager.cache.CacheObject;
import org.kepler.objectmanager.cache.LocalRepositoryManager;
import org.kepler.objectmanager.lsid.KeplerLSID;

import ptolemy.actor.gui.TableauFrame;

/**
 * A KAR file is just a jar file that requires a manifest to be present that has
 * "KAR-Version" and "lsid" main attributes. This KARFile is used for reading
 * KAR files. For Writing KARFiles see KARBuilder class.
 * 
 * @author Aaron Schultz
 */
public class KARFile extends JarFile implements Serializable {
        private static final long serialVersionUID = 1522142700198331341L;
        private static final Log log = LogFactory.getLog(KARFile.class.getName());
        private static final boolean isDebugging = log.isDebugEnabled();

        /**
         * This is the current KAR version.
         */
        public static final String VERSION_2_1 = "2.1";
        public static final String CURRENT_VERSION = VERSION_2_1;
        
        /**
         * Old versions still supported.
         */
        public static final String VERSION_2_0 = "2.0";
        public static final String VERSION_1_0 = "1.0";
        
        //TODO these variables might be better placed elsewhere
        /** "strict"*/
        public static final String KAR_COMPLIANCE_STRICT = "strict";
        /** "relaxed"*/
        public static final String KAR_COMPLIANCE_RELAXED = "relaxed";
        /** "relaxed" if you change this you should also change KARFILE_CONFIG_PROP_MODULE's configuration.xml
         we need to keep both for users that started with an earlier version of configuration.xml
         that lacks the KAR_COMPLIANCE_PROPERTY
         */
        public static final String KAR_COMPLIANCE_DEFAULT = KAR_COMPLIANCE_RELAXED;
        /** "KARComplianceMode"*/
        public static final String KAR_COMPLIANCE_PROPERTY_NAME = "KARComplianceMode";
        /** "core" Module*/
        public static final Module KARFILE_CONFIG_PROP_MODULE = ConfigurationManager.getModule("core");

        /** "karVersions"*/
        public static final String KAR_VERSIONS_PROPERTY_NAME = "karVersions";
        /** "currentVersion" sub-element of karVersions*/
        public static final String KAR_CURRENT_VERSION_PROPERTY_NAME = "currentVersion";
        /** "karVersion" sub-element of karVersions*/
        public static final String KAR_VERSION_PROPERTY_NAME = "karVersion";
        /** "version" sub-element of karVersion*/
        public static final String KAR_VERSION_VERSION_PROPERTY_NAME = "version";
        /** "namespace" sub-element of karVersion*/
        public static final String KAR_VERSION_NAMESPACE_PROPERTY_NAME = "namespace";
        /** "schemaUrl" sub-element of karVersion*/
        public static final String KAR_VERSION_SCHEMAURL_PROPERTY_NAME = "schemaUrl";
        /** "resourceDir" sub-element of karVersion*/
        public static final String KAR_VERSION_RESOURCEDIR_PROPERTY_NAME = "resourceDir";
        /** "resourceFileName" sub-element of karVersion*/
        public static final String KAR_VERSION_RESOURCE_FILENAME_PROPERTY_NAME = "resourceFileName";
        
        //if you change any of these you must also change KARFILE_CONFIG_PROP_MODULE's configuration.xml
        public static final String KAR_CURRENT_VERSION_DEFAULT = "2.1";
        public static final String KAR_VERSION_200_RESOURCEDIR_DEFAULT = "kar-2.0.0";
        public static final String KAR_VERSION_200_RESOURCE_FILENAME_DEFAULT = "KARFile.xsd";
        public static final String KAR_VERSION_200_VERSION_DEFAULT = "2.0";
        public static final String KAR_VERSION_200_NAMESPACE_DEFAULT = "http://www.kepler-project.org/kar-2.0.0";
        public static final String KAR_VERSION_200_SCHEMAURL_DEFAULT = "https://code.kepler-project.org/code/kepler/branches/releases/release-branches/core-2.0/resources/KARFile.xsd";
        public static final String KAR_VERSION_210_RESOURCEDIR_DEFAULT = "kar-2.1.0";
        public static final String KAR_VERSION_210_RESOURCE_FILENAME_DEFAULT = "KARFile-2.1.0.xsd";
        public static final String KAR_VERSION_210_VERSION_DEFAULT = "2.1";
        public static final String KAR_VERSION_210_NAMESPACE_DEFAULT = "http://www.kepler-project.org/kar-2.1.0";
        public static final String KAR_VERSION_210_SCHEMAURL_DEFAULT = "https://code.kepler-project.org/code/kepler/branches/releases/release-branches/core-2.1/resources/KARFile-2.1.0.xsd";

        /**
         * This is the File extension to be used for KAR files.
         */
        public static final String EXTENSION = "kar";

        /**
         * This is the list of all supported versions.
         */
        private Vector<String> _supportedVersions = new Vector<String>();

        /**
         * <code>Name</code> object for <code>lsid</code> manifest attribute used
         * for globally identifying KAREntries as unique.
         */
        public static final Name LSID = new Name("lsid");

        /**
         * <code>Name</code> object for <code>KAR-Version</code> manifest attribute.
         * This attribute indicates the version number of the manifest standard to
         * which a KAR file's manifest conforms.
         */
        public static final Name KAR_VERSION = new Name("KAR-Version");

        /**
         * <code>Name</code> object for <code>MOD_DEPEND</code> manifest attribute.
         * This attribute indicates modules that are needed in order to open this
         * KAR file.
         */
        public static final Name MOD_DEPEND = new Name("module-dependencies");
        
        /**
         * <code>Name</code> object for <code>OPENABLE</code> manifest attribute.
         * This attribute indicates whether or not this KAR file is openable.
         */
        public static final Name OPENABLE = new Name("openable");

        /**
         * Separator to be used for dependency lists.
         */
        public static final String DEP_SEPARATOR = ";";

        /**
         * If the KARFile object was created from a KARFile on disk this is the File
         * path and name of that file.
         */
        private File _fileOnDisk;

        /**
         * A list of all the entry types contained in this KARFile indexed by LSID.
         */
        private Hashtable<KeplerLSID, String> _lsidTypes = new Hashtable<KeplerLSID, String>();

        /**
         * A list of all the entry names contained in this KARFile indexed by LSID.
         */
        private Hashtable<KeplerLSID, String> _lsidNames = new Hashtable<KeplerLSID, String>();

        /**
         * Constructor for creating a KARFile from an existing file.
         * 
         * @param f
         *            the file to create the KAR from
         * @throws IOException
         */
        public KARFile(File f) throws IOException {
                super(f);
                if (isDebugging)
                        log.debug("KARFile(" + f + ")");

                _fileOnDisk = f;

                initializeSupportedVersions();

                if (getManifest() == null) {
                        throw new IOException("This KAR file does not contain a Manifest.");
                }

                String lsidStr = getManifest().getMainAttributes().getValue(LSID);
                if (isDebugging)
                        log.debug(lsidStr);
                if (lsidStr == null) {
                        throw new IOException(
                                        "The KAR file does not contain an lsid attribute in the manifest");
                }
                if (!KeplerLSID.isKeplerLSIDFormat(lsidStr)) {
                        throw new IOException(
                                        "The LSID of the KAR file is not properly formatted.");
                }

                String version = getManifest().getMainAttributes()
                                .getValue(KAR_VERSION);
                if (version == null) {
                        throw new IOException(
                                        "The KAR file does not contain a KAR-Version attribute in the manifest.");
                }
                if (!_supportedVersions.contains(version)) {
                        throw new IOException(version
                                        + " is not a supported KAR version.\n"
                                        + getSupportedVersionString());
                }

                Enumeration<JarEntry> karFileEnum = entries();
                while (karFileEnum.hasMoreElements()) {
                        JarEntry entry = (JarEntry) karFileEnum.nextElement();
                        KeplerLSID lsid = getEntryLSID(entry);
                        String type = getEntryType(entry);
                        if (lsid != null && type != null) {
                                _lsidNames.put(lsid, entry.getName());
                                _lsidTypes.put(lsid, type);
                        }
                }

        }

        private void initializeSupportedVersions() {
                _supportedVersions.add(VERSION_1_0);
                _supportedVersions.add(VERSION_2_0);
                _supportedVersions.add(VERSION_2_1);
        }

        public KeplerLSID getLSID() {
                try {
                        return new KeplerLSID(getManifest().getMainAttributes().getValue(
                                        LSID));
                } catch (Exception e) {
                        return null;
                }
        }

        /**
         * @param lsid
         * @throws IOException
         */
        public void setLSID(KeplerLSID lsid) throws IOException {
                Attributes atts = getManifest().getMainAttributes();
                if (atts.containsKey(LSID)) {
                        atts.remove(LSID);
                }
                atts.put(LSID, lsid.toString());
        }

        public String getKARVersion() {
                try {
                        Attributes atts = getManifest().getMainAttributes();
                        String karVersion = atts.getValue(KAR_VERSION);
                        return karVersion;
                } catch (IOException e) {
                        return null;
                }
        }
        
        public boolean isOpenable() {
                try {
                        Attributes atts = getManifest().getMainAttributes();
                        String openable = atts.getValue(OPENABLE);
                        if (openable != null) {
                                openable = openable.trim();
                                if (openable.equalsIgnoreCase("false")) {
                                        return false;
                                }
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                }
                Vector<String>moduleDependencies = getModuleDependencies();
                if (ModuleDependencyUtil.checkIfModuleDependenciesSatisfied(moduleDependencies)){
                        return true;
                }
                return false;
        }

        /**
         * Set the version of the KARFile.
         * 
         * @param version
         * @throws IOException
         *             if the given version is not supported
         */
        public void setVersion(String version) throws IOException {
                if (_supportedVersions.contains(version)) {
                        Attributes atts = getManifest().getMainAttributes();
                        if (atts.containsKey(KAR_VERSION)) {
                                atts.remove(KAR_VERSION);
                        }
                        atts.put(KAR_VERSION, version);
                } else {
                        throw new IOException(version
                                        + " is not a supported KAR version.\n"
                                        + getSupportedVersionString());
                }
        }

        public Vector<String> getModuleDependencies() {
                Vector<String> dependencies = new Vector<String>();
                try {
                        String depStr = getManifest().getMainAttributes().getValue(
                                        MOD_DEPEND);
                        if (depStr == null) {
                                return dependencies;
                        }
                        dependencies = ModuleDependencyUtil.parseDependencyString(depStr);
                } catch (Exception e) {
                }
                return dependencies;
        }

        /**
         * Return the LSIDs of all of the entries contained by this KARFile.
         * 
         * */
        public Set<KeplerLSID> getContainedLSIDs() {
                return _lsidTypes.keySet();
        }

        public String getEntryType(KeplerLSID lsid) {
                return _lsidTypes.get(lsid);
        }

        public String getEntryName(KeplerLSID lsid) {
                return _lsidNames.get(lsid);
        }

        /**
         * Return the name of the local repository that this KAR is stored in.
         * 
         * @return null if no name is found
         */
        public String getLocalRepoName() {
                LocalRepositoryManager lrm = LocalRepositoryManager.getInstance();
                LocalRepositoryManager.LocalRepository repository = lrm.getContainingLocalRepository(getFileLocation());
                if(repository != null) {
                    return lrm.getLocalRepositories().get(repository);
                }
                return null;
        }

        /**
         * Return the path where this kar file is found on disk.
         */
        public String getPath() {
                String filePath = getFileLocation().getPath();
                String fileName = getFileLocation().getName();
                if (isDebugging)
                        log.debug(filePath + "   " + fileName);

                if (filePath.endsWith(fileName)) {
                        // remove the filename
                        int i = filePath.length() - fileName.length();
                        if (i > 0) {
                                filePath = filePath.substring(0, i);
                        }
                        if (isDebugging)
                                log.debug("New filePath: " + filePath);
                }
                return filePath;
        }

        public File getFileLocation() {
                return _fileOnDisk;
        }

        /**
         * returns a KAREntry for the given lsid. If there is not KAREntry then
         * return null.
         * 
         * @param name
         *            the name of the entry to return
         */
        public ZipEntry getKAREntry(KeplerLSID lsid) {
                String path = _lsidNames.get(lsid);
                ZipEntry ze = super.getEntry(path);
                if (ze != null) {
                        return ze;
                }
                return null;
        }

        /**
         * Returns only valid KAREntries contained in this KARFile. To get all of
         * the JarEntries use the entries() method.
         * 
         * @return List<KAREntry> of all valid KAREntries in this KARFile.
         */
        public List<KAREntry> karEntries() {
                if (isDebugging)
                        log.debug("karEntries()");
                Enumeration<JarEntry> entries = entries();
                Vector<KAREntry> karEntries = new Vector<KAREntry>();
                while (entries.hasMoreElements()) {
                        JarEntry entry = entries.nextElement();
                        if (isDebugging)
                                log.debug(entry.getName());
                        if (entry.getName().equals("MANIFEST.MF")
                                        || entry.getName().equals("META-INF/")
                                        || entry.getName().equals(JarFile.MANIFEST_NAME)) {
                                // skip manifest entries
                        } else {
                                KAREntry karEntry = new KAREntry(entry);
                                if (karEntry.isValid()) {
                                        if (isDebugging)
                                                log.debug("karEntry.isValid() == true");
                                        karEntries.add(karEntry);
                                } else {
                                        if (isDebugging)
                                                log.debug("karEntry.isValid() == false");
                                }
                        }
                }
                return karEntries;
        }

        /**
         * Return an array of lsids of a certain type from within this kar. if the
         * type is null return all of the lsids
         * 
         * @param getType
         *            the type of the content to get
         */
        public KeplerLSID[] getContentOfType(String getType) throws Exception {

                Vector<KeplerLSID> returnVec = new Vector<KeplerLSID>();
                for (KeplerLSID lsid : this.getContainedLSIDs()) {
                        String type = this.getEntryType(lsid);
                        if (getType == null || getType.equals(type)) {
                                returnVec.addElement(lsid);
                        } else if (isSubclass(getType, type)) {
                                returnVec.addElement(lsid);
                        }
                }

                KeplerLSID[] lsids = new KeplerLSID[returnVec.size()];
                for (int i = 0; i < returnVec.size(); i++) {
                        lsids[i] = (KeplerLSID) returnVec.elementAt(i);
                }
                return lsids;
        }

        /**
         * Determine if type is a subclass of getType. This belongs in a UTIL class
         * somewhere?
         * 
         * @param getType
         * @param type
         * @return
         * @throws ClassNotFoundException
         */
        public static boolean isSubclass(String getType, String type)
                        throws ClassNotFoundException {
                
                // protect against nulls
                if (getType == null || type == null)
                        return false;

                // the superclass test
                Class getClazz = Class.forName(getType);

                // handle superclasses
                Class theClazz = Class.forName(type);
                Class superClazz = theClazz.getSuperclass();
                while (superClazz != null) {
                        if (superClazz.getName().equals(getClazz.getName())) {
                                return true;
                        }
                        superClazz = superClazz.getSuperclass();
                }
                return false;
        }

        /**
         * @return String of the supported KAR versions.
         */
        private String getSupportedVersionString() {
                String s = "Supported KAR versions:\n";
                for (String v : _supportedVersions) {
                        s += "      " + v + "\n";
                }
                return s;
        }

        /**
         * Read the LSID from the attributes of the given entry and return it as a
         * KeplerLSID.
         * 
         * @param entry
         * @return
         * @throws IOException
         */
        private KeplerLSID getEntryLSID(JarEntry entry) throws IOException {
                Attributes atts = entry.getAttributes();
                if (atts == null) {
                        return null;
                }

                String lsidStr = atts.getValue(KAREntry.LSID);
                if (lsidStr == null) {
                        log.error("KAREntries must have an LSID and a type.");
                        return null;
                }

                KeplerLSID lsid = null;
                try {
                        lsid = new KeplerLSID(lsidStr);
                } catch (Exception e) {
                        log.warn(lsidStr + " is not a properly formatted KeplerLSID");
                        return null;
                }
                return lsid;
        }

        /**
         * Read the type attribute from the given entry and return it as a string.
         * 
         * @param entry
         * @return
         * @throws IOException
         */
        private String getEntryType(JarEntry entry) throws IOException {
                Attributes atts = entry.getAttributes();
                if (atts == null) {
                        return null;
                }
                String type = atts.getValue(KAREntry.TYPE);
                return type;
        }

        /**
         * This method makes sure that all of the entries of this KARFile are in the
         * Cache. It caches the entries in the order that their dependencies
         * dictate.
         * 
         * @throws Exception
         */
        public void cacheKARContents() throws Exception {
                if (isDebugging) {
                        log.debug("openKAR: " + this.toString());
                }
                try {
                        // get references to all the managers we'll be using
                        LocalRepositoryManager lrm = LocalRepositoryManager.getInstance();
                        KARCacheManager kcm = KARCacheManager.getInstance();
                        CacheManager cm = CacheManager.getInstance();

                        // Make sure the file is in a local repository
                        if (!lrm.isInLocalRepository(getFileLocation())) {
                                log
                                                .warn("KAR should be in a Local Repository Folder to be inserted in the cache: "
                                                                + getFileLocation());
                                // return;
                        }

                        // Add a row to the KARS_CACHED table
                        boolean inserted = kcm.insertIntoCache(this);
                        if (!inserted) {
                                // This KAR has already been cached, don't do it again
                                return;
                        }

                        // keep two lists while traversing the dependencies, start with all
                        // of the entries (we don't know yet if they are cached or not)
                        // and move them into the cached entries as they are cached (or if
                        // they are already cached)
                        Vector<KAREntry> entries = (Vector<KAREntry>) karEntries();
                        Hashtable<KeplerLSID, KAREntry> cachedEntries = new Hashtable<KeplerLSID, KAREntry>();

                        // do one pass through the entries to see if any of them are already
                        // in the cache
                        for (KAREntry entry : entries) {
                                KeplerLSID lsid = entry.getLSID();

                                // See if this entry is already in the Cache
                                boolean alreadyCached = cm.isContained(lsid);
                                if (alreadyCached) {

                                        // add this entry into the cachedEntries list
                                        cachedEntries.put(entry.getLSID(), entry);

                                        // Insert a row into the KAR_CONTENTS table for this entry
                                        File karFile = getFileLocation();
                                        KeplerLSID entryLsid = entry.getLSID();
                                        String entryName = entry.getName();
                                        String entryType = entry.getType();
                                        kcm.insertEntryIntoCache(karFile, entryLsid, entryName,
                                                        entryType);
                                }
                        }

                        // remove entries that were already cached
                        for (KAREntry entry : cachedEntries.values()) {
                                entries.remove(entry);
                        }

                        // keep cycling through the uncached entries until the list is empty
                        while (entries.size() > 0) {

                                // keep track of the entries cached during this pass
                                Vector<KAREntry> cachedThisPass = new Vector<KAREntry>(entries
                                                .size());

                                // cycle through all of the remaining, uncached entries
                                for (KAREntry entry : entries) {
                                        if (isDebugging)
                                                log.debug(entry.getName());

                                        // get the dependency list for this entry
                                        List<KeplerLSID> depList = entry.getLsidDependencies();

                                        if (depList.size() == 0) {
                                                // if there are no dependencies we just cache it
                                                boolean success = cache(entry);
                                                if (success) {
                                                        cachedEntries.put(entry.getLSID(), entry);
                                                        cachedThisPass.add(entry);
                                                        break;
                                                }
                                                if (isDebugging)
                                                        log.debug(success);
                                        } else {
                                                // if there are dependencies then we check to make sure
                                                // that all of the dependencies have already been cached
                                                boolean allDependenciesHaveBeenCached = true;
                                                for (KeplerLSID lsid : depList) {
                                                        // if any of the dependencies have not been cached,
                                                        // set false
                                                        if (!cm.isContained(lsid)) {
                                                                allDependenciesHaveBeenCached = false;
                                                        }
                                                }
                                                if (allDependenciesHaveBeenCached) {
                                                        // all dependencies have been cached so it is
                                                        // OK to cache this entry
                                                        boolean success = cache(entry);
                                                        if (success) {
                                                                cachedEntries.put(entry.getLSID(), entry);
                                                                cachedThisPass.add(entry);
                                                                break;
                                                        }
                                                        if (isDebugging)
                                                                log.debug(success);
                                                }
                                        }
                                }
                                if (cachedThisPass.size() == 0) {
                                        // Bad news, nothing is getting cached
                                        // This means that there are uncached entries that
                                        // have unsatisfied dependencies
                                        // break out to avoid infinite loop
                                        // Vector<KAREntry> entriesWithBrokenDependencies = entries;
                                        break;
                                }

                                // remove any entries that got cached this pass
                                for (KAREntry entry : cachedThisPass) {
                                        entries.remove(entry);
                                }

                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }

        }

        /**
         * Here we go through all the KAREntries and call the open method of the
         * appropriate KAREntryHandlers. It is assumed that cacheKARContents() has
         * been called at some point before openKAR() In other words everything in
         * the kar is already cached when calling the open() method of the
         * KAREntryHandlers.
         * 
         * Note: There is some issue with having this method here, since it is
         * really a gui specific function it probably does not belong here in the
         * core module.
         * 
         * @param tableauFrame
         * @param forceOpen
         * @throws Exception
         * @returns true if at least one of the entries in the KAR was opened
         */
        public boolean openKARContents(TableauFrame tableauFrame, boolean forceOpen) throws Exception {
                if (isDebugging)
                        log.debug("openKAR: " + this.toString());
                
                if (!forceOpen && !isOpenable()){
                        return false;
                }
                
                try {

                        /**
                         * Loop through the kar entries and call the open method of the
                         * appropriate KAREntryHandler
                         */
                        Vector<KAREntry> unopenedEntries = (Vector<KAREntry>) karEntries();
                        Hashtable<KeplerLSID, KAREntry> openedEntries = new Hashtable<KeplerLSID, KAREntry>();

                        // keep cycling through the unopened entries until the list is empty
                        while (unopenedEntries.size() > 0) {

                                // keep track of the entries that were opened during this pass
                                Vector<KAREntry> openedThisPass = new Vector<KAREntry>(
                                                unopenedEntries.size());

                                // cycle through all of the remaining, unopened entries
                                for (KAREntry entry : unopenedEntries) {
                                        if (isDebugging) {
                                                log.debug(entry.getName());
                                        }

                                        // get the dependency list for this entry
                                        List<KeplerLSID> depList = entry.getLsidDependencies();

                                        if (depList.size() == 0) {
                                                // if there are no dependencies we just open it up
                                                boolean success = open(entry, tableauFrame);
                                                if (success) {
                                                        openedEntries.put(entry.getLSID(), entry);
                                                        openedThisPass.add(entry);
                                                        break;
                                                }
                                                if (isDebugging)
                                                        log.debug(success);
                                        } else {
                                                // if there are dependencies then we check to make sure
                                                // that all of the dependencies have already been opened
                                                boolean allDependenciesHaveBeenOpened = true;
                                                for (KeplerLSID lsid : depList) {
                                                        // if any of the dependencies have not been opened,
                                                        // set false
                                                        if (!openedEntries.containsKey(lsid)) {
                                                                allDependenciesHaveBeenOpened = false;
                                                        }
                                                }
                                                if (allDependenciesHaveBeenOpened) {
                                                        // dependencies have been opened so OK to open this
                                                        // one
                                                        boolean success = open(entry, tableauFrame);
                                                        if (success) {
                                                                openedEntries.put(entry.getLSID(), entry);
                                                                openedThisPass.add(entry);
                                                                break;
                                                        }
                                                        if (isDebugging)
                                                                log.debug(success);
                                                }
                                        }
                                }

                                if (openedThisPass.size() == 0) {
                                        // Bad news, nothing is getting opened
                                        // break out to avoid infinite loop
                                        break;
                                }

                                // remove the entries that were opened during this pass
                                for (KAREntry entry : openedThisPass) {
                                        unopenedEntries.remove(entry);
                                }
                        }
                        

                        if (openedEntries.size() == 0) {
                                return false;
                        }
                } catch (Exception e) {
                        throw new Exception("Error on Open: " + e.getMessage());
                }
                return true;
        }

        /**
         * Get all the KAREntryHandlers that can handle the given entry.
         * 
         * @param entry
         * @return KAREntryHandlers that can handle the given entry.
         */
        private Vector<KAREntryHandler> getHandlersForEntry(KAREntry entry) {
                Vector<KAREntryHandler> handlers = new Vector<KAREntryHandler>(2);

                // First we make sure that the EntryHandler that wrote the entry
                // is present in the system
                try {
                        // check for it in the classpath
                        Class.forName(entry.getHandler());
                } catch (Exception e) {
                        log.warn("KAREntryHandler not in classpath: " + entry.getHandler());
                        return handlers;
                }

                try {
                        // check to see if it is registered with the KAREntryHandler
                        // extension point
                        boolean writeHandlerPresent = false;
                        for (KAREntryHandler k : CacheManager.getInstance()
                                        .getKAREntryHandlers()) 
                        {
                                if (k.getClass().getName().equals(entry.getHandler())) {
                                        writeHandlerPresent = true;
                                        break;
                                }
                        }
                        if (writeHandlerPresent) {
                                // continue looking for EntryHandlers that handle this type
                        } else {
                                log.warn("KAREntryHandler is not registered with suite: "
                                                + entry.getHandler());
                                return handlers;
                        }
                } catch (CacheException e1) {
                        e1.printStackTrace();
                } catch (Exception e) {
                }

                KeplerLSID lsid = entry.getLSID();
                String type = entry.getType();
                if (isDebugging)
                        log.debug(lsid + " " + type);
                if (lsid == null || type == null) {
                        return null;
                }
                try {
                        if (getKARVersion().equals(VERSION_1_0)) {
                                // In version 1.0 KARs the type is a one word string
                                // that identifies what type of file it is
                                for (KAREntryHandler k : CacheManager.getInstance()
                                                .getKAREntryHandlers()) {
                                        if (k.getTypeName().equals(type)) {
                                                handlers.add(k);
                                        }
                                }
                        } else if (getKARVersion().equals(VERSION_2_0) || 
                                getKARVersion().equals(VERSION_2_1)) {
                                // In version 2.0 and 2.1 KARs the type is the binary class
                                // name for the type of file that the KAREntry is.
                                // A KAREntryHandler may be able to handle more than
                                // one type in version 2.0 and 2.1
                                for (KAREntryHandler k : CacheManager.getInstance()
                                                .getKAREntryHandlers()) {
                                        if (k.handlesType(type)) {
                                                handlers.add(k);
                                        }
                                }
                        }
                } catch (CacheException e) {
                        e.printStackTrace();
                }
                return handlers;
        }

        /**
         * Insert the object into the cache and record it in the kar contents table.
         * 
         * @param entry
         * @return true if the entry could be cached
         */
        private boolean cache(KAREntry entry) {
                if (entry.getAttributes() == null) {
                        return false;
                }

                CacheManager cm;
                KARCacheManager kcm;
                try {
                        cm = CacheManager.getInstance();
                        kcm = KARCacheManager.getInstance();

                        if (cm.isContained(entry.getLSID())) {
                                // This entry is already cached
                                // make sure there is a row for it in the KAR_CONTENTS table
                                File karFile = getFileLocation();
                                KeplerLSID entryLsid = entry.getLSID();
                                String entryName = entry.getName();
                                String entryType = entry.getType();
                                kcm.insertEntryIntoCache(karFile, entryLsid, entryName,
                                                entryType);
                                return true;
                        }
                } catch (CacheException e1) {
                        e1.printStackTrace();
                        return false;
                }

                // get all KAREntryHandlers for this KAREntry
                Vector<KAREntryHandler> handlers = getHandlersForEntry(entry);
                if (handlers == null)
                        return false;

                if (handlers.size() <= 0) {
                        // this KAREntry type is not recognized ignore it
                        log.warn("No KAREntryHandlers found for KAREntry: " + entry.getName() +" ignoring this item.");
                        return false;
                }

                // loop through all of the handlers and pass the entry to their cache
                // method
                // if they return a cache object then insert it into the cache.
                for (KAREntryHandler keh : handlers) {
                        try {
                                CacheObject co = keh.cache(this, entry);
                                if (co != null) {

                                        // The handler returned a CacheObject, insert it into the
                                        // cache
                                        cm.insertObject(co);

                                        // Insert a row into the KAR_CONTENTS table for this entry
                                        File karFile = getFileLocation();
                                        KeplerLSID entryLsid = entry.getLSID();
                                        String entryName = entry.getName();
                                        String entryType = entry.getType();
                                        kcm.insertEntryIntoCache(karFile, entryLsid, entryName,
                                                        entryType);

                                }
                        } catch (CacheException ce) {
                                log.warn("KAREntry was not cached: " + entry.getName());
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }

                return true;
        }

        /**
         * Call the open methods of all KAREntryHandlers that support the type of
         * the given entry.
         * 
         * @param entry
         * @param tableauFrame
         * @return
         */
        public boolean open(KAREntry entry, TableauFrame tableauFrame) {
                Vector<KAREntryHandler> handlers = getHandlersForEntry(entry);
                if (handlers == null)
                        return false;

                if (handlers.size() <= 0) {
                        // this KAREntry type is not recognized ignore it
                        log.warn("No KAREntryHandlers found for KAREntry: " + entry.getName() +" ignoring this item.");
                        return false;
                }

                boolean allsuccess = true;
                for (KAREntryHandler keh : handlers) {
                        try {
                                boolean success = keh.open(this, entry, tableauFrame);
                                if (!success) {
                                        allsuccess = false;
                                }
                                if (isDebugging)
                                        log.debug(success);
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }
                return allsuccess;

        }
        
        public boolean areAllModuleDependenciesSatisfied(){
                return ModuleDependencyUtil.checkIfModuleDependenciesSatisfied(this.getModuleDependencies());
        }

        /** Get a map of missing module dependencies. */
        public Map<String, Version> getMissingDependencies() {
                
                List<String> dependencies = getModuleDependencies();
                return ModuleDependencyUtil.getUnsatisfiedDependencies(dependencies);

        }
        
        /**
         * @return karVersions configuration property, adding it to config file
         * if it doesn't exist.
         */
        public static ConfigurationProperty getKARVersionsConfigProperty() {
                
                ConfigurationManager cman = ConfigurationManager.getInstance();
                ConfigurationProperty coreProperty = cman
                                .getProperty(KARFILE_CONFIG_PROP_MODULE);
                ConfigurationProperty KARVersionsProp = coreProperty
                        .getProperty(KAR_VERSIONS_PROPERTY_NAME);
                
                try {
                
                        // add karVersions configuration property (and all sub props) if
                        // necessary
                        if (KARVersionsProp == null) {
                                KARVersionsProp = new ConfigurationProperty(
                                                KARFILE_CONFIG_PROP_MODULE, KAR_VERSIONS_PROPERTY_NAME);
                                coreProperty.addProperty(KARVersionsProp);

                                ConfigurationProperty KARCurrentVersionProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_CURRENT_VERSION_PROPERTY_NAME,
                                                KARFile.KAR_CURRENT_VERSION_DEFAULT);

                                ConfigurationProperty KARVersion200Prop = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_PROPERTY_NAME);
                                ConfigurationProperty KARVersion200VersionProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_VERSION_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_200_VERSION_DEFAULT);
                                ConfigurationProperty KARVersion200SchemaUrlProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_SCHEMAURL_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_200_SCHEMAURL_DEFAULT);
                                ConfigurationProperty KARVersion200NamespaceProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_NAMESPACE_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_200_NAMESPACE_DEFAULT);
                                ConfigurationProperty KARVersion200ResourceDirProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_RESOURCEDIR_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_200_RESOURCEDIR_DEFAULT);
                                ConfigurationProperty KARVersion200ResourceFileNameProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_RESOURCE_FILENAME_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_200_RESOURCE_FILENAME_DEFAULT);
                                
                                ConfigurationProperty KARVersion210Prop = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_PROPERTY_NAME);
                                ConfigurationProperty KARVersion210VersionProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_VERSION_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_210_VERSION_DEFAULT);
                                ConfigurationProperty KARVersion210SchemaUrlProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_SCHEMAURL_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_210_SCHEMAURL_DEFAULT);
                                ConfigurationProperty KARVersion210NamespaceProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_NAMESPACE_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_210_NAMESPACE_DEFAULT);
                                ConfigurationProperty KARVersion210ResourceDirProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_RESOURCEDIR_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_210_RESOURCEDIR_DEFAULT);
                                ConfigurationProperty KARVersion210ResourceFileNameProp = new ConfigurationProperty(
                                                KARFile.KARFILE_CONFIG_PROP_MODULE,
                                                KARFile.KAR_VERSION_RESOURCE_FILENAME_PROPERTY_NAME,
                                                KARFile.KAR_VERSION_210_RESOURCE_FILENAME_DEFAULT);

                                KARVersion200Prop.addProperty(KARVersion200VersionProp);
                                KARVersion200Prop.addProperty(KARVersion200SchemaUrlProp);
                                KARVersion200Prop.addProperty(KARVersion200NamespaceProp);
                                KARVersion200Prop.addProperty(KARVersion200ResourceDirProp);
                                KARVersion200Prop.addProperty(KARVersion200ResourceFileNameProp);

                                KARVersion210Prop.addProperty(KARVersion210VersionProp);
                                KARVersion210Prop.addProperty(KARVersion210SchemaUrlProp);
                                KARVersion210Prop.addProperty(KARVersion210NamespaceProp);
                                KARVersion210Prop.addProperty(KARVersion210ResourceDirProp);
                                KARVersion210Prop.addProperty(KARVersion210ResourceFileNameProp);

                                KARVersionsProp.addProperty(KARCurrentVersionProp);
                                KARVersionsProp.addProperty(KARVersion200Prop);
                                KARVersionsProp.addProperty(KARVersion210Prop);
                        }

                } catch (NamespaceException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (ConfigurationManagerException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                return KARVersionsProp;
                
        }
        
        /**
         * 
         * @return all KAR namespaces found in karVersions config property
         */
        public static List<String> getKARNamespaces() {

                List<String> namespaces = new ArrayList<String>();
                ConfigurationProperty KARVersionsProp = KARFile.getKARVersionsConfigProperty();

                Iterator<ConfigurationProperty> karVersionsItr = KARVersionsProp
                        .getProperties().iterator();
                
                while (karVersionsItr.hasNext()) {
                        ConfigurationProperty prop = karVersionsItr.next();
                        if (prop.getName().equals(KAR_VERSION_PROPERTY_NAME)) {
                                ConfigurationProperty namespaceConfigProp = prop
                                        .getProperty(KAR_VERSION_NAMESPACE_PROPERTY_NAME);
                                namespaces.add(namespaceConfigProp.getValue());
                        }
                }

                return namespaces;
        }

        /**
         * Return the local resource dir associated with given namespace, 
         * null if can't be found.
         * 
         * @param namespace
         * @return
         */
        public static String getResourceDir(String namespace) {
                ConfigurationProperty KARVersionsProp = KARFile
                                .getKARVersionsConfigProperty();

                Iterator<ConfigurationProperty> karVersionsItr = KARVersionsProp
                                .getProperties().iterator();

                while (karVersionsItr.hasNext()) {
                        ConfigurationProperty prop = karVersionsItr.next();
                        if (prop.getName().equals(KAR_VERSION_PROPERTY_NAME)) {
                                String namespaceFromConfig = prop
                                                .getProperty(KAR_VERSION_NAMESPACE_PROPERTY_NAME).getValue();
                                if (namespace.equals(namespaceFromConfig)){
                                        return prop.getProperty(KAR_VERSION_RESOURCEDIR_PROPERTY_NAME).getValue();
                                }
                        }
                }
                if (isDebugging)
                        log.error("Couldn't find resourceDir associated with namespace:"+namespace + " return null");
                return null;
        }
        
        /**
         * Return the local resource filename associated with given namespace, 
         * null if can't be found.
         * 
         * @param namespace
         * @return
         */
        public static String getResourceFileName(String namespace) {
                ConfigurationProperty KARVersionsProp = KARFile
                                .getKARVersionsConfigProperty();

                Iterator<ConfigurationProperty> karVersionsItr = KARVersionsProp
                                .getProperties().iterator();

                while (karVersionsItr.hasNext()) {
                        ConfigurationProperty prop = karVersionsItr.next();
                        if (prop.getName().equals(KAR_VERSION_PROPERTY_NAME)) {
                                String namespaceFromConfig = prop
                                                .getProperty(KAR_VERSION_NAMESPACE_PROPERTY_NAME).getValue();
                                if (namespace.equals(namespaceFromConfig)){
                                        return prop.getProperty(KAR_VERSION_RESOURCE_FILENAME_PROPERTY_NAME).getValue();
                                }
                        }
                }
                if (isDebugging)
                        log.error("Couldn't find resourceFileName associated with namespace:"+namespace + " return null");
                return null;
        }

}