/*
 * 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.netbeans.core.netigso;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.ArchiveResources;
import org.netbeans.Module;
import org.netbeans.Module.PackageExport;
import org.netbeans.NetigsoFramework;
import org.netbeans.ProxyClassLoader;
import org.netbeans.Stamps;
import static org.netbeans.core.netigso.Bundle.*;
import org.netbeans.core.startup.Main;
import org.openide.modules.ModuleInfo;
import org.openide.modules.Places;
import org.openide.util.*;
import org.openide.util.NbBundle.Messages;
import org.openide.util.lookup.ServiceProvider;
import org.openide.util.lookup.ServiceProviders;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.Version;
import org.osgi.framework.launch.Framework;
import org.osgi.framework.launch.FrameworkFactory;
import org.osgi.service.packageadmin.PackageAdmin;
import org.osgi.service.packageadmin.RequiredBundle;
import org.osgi.service.startlevel.StartLevel;

/**
 *
 * @author Jaroslav Tulach <jtulach@netbeans.org>
 */
@ServiceProviders({
    @ServiceProvider(service = NetigsoFramework.class),
    @ServiceProvider(service = Netigso.class)
})
public final class Netigso extends NetigsoFramework 
implements Cloneable, Stamps.Updater {
    static final Logger LOG = Logger.getLogger(Netigso.class.getName());
    private static final AtomicBoolean SELF_QUERY = new AtomicBoolean();
    private static final String[] EMPTY = {};

    private Framework framework;
    private ClassLoader frameworkLoader;
    private NetigsoActivator activator;
    private Integer defaultStartLevel;
    private String defaultCoveredPkgs;
    
    @Override
    protected NetigsoFramework clone() {
        return new Netigso();
    }

    Framework getFramework() {
        return framework;
    }
    @Override
    protected ClassLoader findFrameworkClassLoader() {
        ClassLoader l = frameworkLoader;
        if (l != null) {
            return l;
        }
        Framework f = framework;
        if (f != null) {
            return frameworkLoader = f.getClass().getClassLoader();
        }
        return getClass().getClassLoader();
    }

    @Override
    @Messages({"#NOI18N", "FRAMEWORK_START_LEVEL="})
    protected void prepare(Lookup lkp, Collection<? extends Module> preregister) {
        if (framework == null) {
            readBundles();
            
            Map configMap = new HashMap();
            injectSystemProperties(configMap); // ensure we read system properties
            final String cache = getNetigsoCache().getPath();
            configMap.put(Constants.FRAMEWORK_STORAGE, cache);
            activator = new NetigsoActivator(this);
            configMap.put("netigso.archive", NetigsoArchiveFactory.DEFAULT.create(this)); // NOI18N
            if (!configMap.containsKey("felix.log.level")) { // NOI18N
                String felixLevel = felixLogLevel(LOG);
                configMap.put("felix.log.level", felixLevel); // NOI18N
            }
            configMap.put("felix.bootdelegation.classloaders", activator); // NOI18N
            String startLevel = FRAMEWORK_START_LEVEL();
            if (!startLevel.isEmpty()) {
                configMap.put("org.osgi.framework.startlevel.beginning", startLevel); // NOI18N
            }
            FrameworkFactory frameworkFactory = lkp.lookup(FrameworkFactory.class);
            if (frameworkFactory == null) {
                throw new IllegalStateException(
                        "Cannot find OSGi framework implementation." + // NOI18N
                        " Is org.netbeans.libs.felix module or similar enabled?" // NOI18N
                        );
            }
            framework = frameworkFactory.newFramework(configMap);
            try {
                System.clearProperty("java.security.manager");
                framework.init();
                NetigsoServices ns = new NetigsoServices(this, framework);
            } catch (BundleException ex) {
                LOG.log(Level.SEVERE, "Cannot start OSGi framework", ex); // NOI18N
            }
            LOG.finer("OSGi Container initialized"); // NOI18N
        }
        for (Module mi : preregister) {
            try {
                fakeOneModule(mi, null);
            } catch (IOException ex) {
                LOG.log(Level.WARNING, "Cannot fake " + mi.getCodeName(), ex);
            }
        }
    }

    static String felixLogLevel(final Logger log) {
        String felixLevel = "1"; // NOI18N
        if (log.isLoggable(Level.WARNING)) {
            felixLevel = "2"; // NOI18N
        }
        if (log.isLoggable(Level.CONFIG)) {
            felixLevel = "3"; // NOI18N
        }
        if (log.isLoggable(Level.FINE)) {
            felixLevel = "4"; // NOI18N
        }
        return felixLevel;
    }

    @Override
    protected Set<String> start(Collection<? extends Module> allModules) {
        return toActivate(framework, allModules);
    }

    @Override
    protected void start() {
        try {
            framework.start();
        } catch (BundleException ex) {
            LOG.log(Level.WARNING, "Cannot start Container" + framework, ex);
        }
    }

    /** contributed by Alex Bowen (trajar@netbeans.org) */
    private void injectSystemProperties(Map configProps) {
        for (Enumeration<?> e = System.getProperties().propertyNames(); e.hasMoreElements(); ) {
            String key = e.nextElement().toString();
            if (key.startsWith("felix.") || key.startsWith("org.osgi.framework.")) { // NOI18N
                configProps.put(key, System.getProperty(key));
            }
        }
    }

    private static Set<String> toActivate(Framework f, Collection<? extends Module> allModules) {
        ServiceReference sr = f.getBundleContext().getServiceReference("org.osgi.service.packageadmin.PackageAdmin"); // NOI18N
        if (sr == null) {
            return null;
        }
        PackageAdmin pkgAdm = (PackageAdmin)f.getBundleContext().getService(sr);
        if (pkgAdm == null) {
            return null;
        }
        Set<String> allCnbs = new HashSet<String>(allModules.size() * 2);
        for (ModuleInfo m : allModules) {
            allCnbs.add(m.getCodeNameBase());
        }
        
        Set<String> needEnablement = new HashSet<String>();
        for (Bundle b : f.getBundleContext().getBundles()) {
            String loc = b.getLocation();
            if (loc.startsWith("netigso://")) {
                loc = loc.substring("netigso://".length());
            } else {
                continue;
            }
            RequiredBundle[] arr = pkgAdm.getRequiredBundles(loc);
            if (arr != null) for (RequiredBundle rb : arr) {
                for (Bundle n : rb.getRequiringBundles()) {
                    if (allCnbs.contains(n.getSymbolicName().replace('-', '_'))) {
                        needEnablement.add(loc);
                    }
                }
            }
        }
        return needEnablement;
    }

    @Override
    protected void shutdown() {
        try {
            if (framework != null) {
                framework.stop();
                framework.waitForStop(10000);
            }
            framework = null;
            frameworkLoader = null;
        } catch (InterruptedException ex) {
            LOG.log(Level.WARNING, "Wait for shutdown failed" + framework, ex);
        } catch (BundleException ex) {
            LOG.log(Level.WARNING, "Cannot start Container" + framework, ex);
        }
    }

    @Override
    @Messages({"#NOI18N", "DEFAULT_BUNDLE_START_LEVEL=0"})
    protected int defaultStartLevel() {
        if (defaultStartLevel == null) {
            defaultStartLevel = Integer.parseInt(DEFAULT_BUNDLE_START_LEVEL());
        }
        return defaultStartLevel;
    }

    @Override
    @Messages({"#NOI18N", "MODULE_START_LEVEL="})
    protected Set<String> createLoader(ModuleInfo m, ProxyClassLoader pcl, File jar) throws IOException {
        try {
            assert registered.containsKey(m.getCodeNameBase()) : m.getCodeNameBase();
            Bundle b = findBundle(m.getCodeNameBase());
            if (b == null) {
                for (Bundle bb : framework.getBundleContext().getBundles()) {
                    LOG.log(Level.FINE, "Bundle {0}: {1}", new Object[] { bb.getBundleId(), bb.getSymbolicName() });
                }
                throw new IOException("Not found bundle:" + m.getCodeNameBase());
            }
            NetigsoLoader l = new NetigsoLoader(b, m, jar);
            Set<String> pkgs = new HashSet<String>();
            String[] knownPkgs = registered.get(m.getCodeNameBase());
            Object exported = b.getHeaders("").get("Export-Package");
            if (knownPkgs == EMPTY) {
                try {
                    SELF_QUERY.set(true);
                    if (findCoveredPkgs(exported)) {
                        Enumeration<URL> en = b.findEntries("", null, true);
                        if (en == null) {
                            LOG.log(Level.INFO, "Bundle {0}: {1} is empty", new Object[] { b.getBundleId(), b.getSymbolicName() });
                        } else {
                            while (en.hasMoreElements()) {
                                URL url = en.nextElement();
                                if (url.getFile().startsWith("/META-INF")) {
                                    pkgs.add(url.getFile().substring(9));
                                    continue;
                                }
                                pkgs.add(url.getFile().substring(1).replaceFirst("/[^/]*$", "").replace('/', '.'));
                            }
                        }
                    }
                    if (exported instanceof String) {
                        for (String p : exported.toString().split(",")) { // NOI18N
                            int semic = p.indexOf(';');
                            if (semic >= 0) {
                                p = p.substring(0, semic);
                            }
                            pkgs.add(p);
                        }
                    }
                } finally {
                    SELF_QUERY.set(false);
                }
                registered.put(m.getCodeNameBase(), pkgs.toArray(new String[0]));
                Stamps.getModulesJARs().scheduleSave(this, "netigso-bundles", false); // NOI18N
            } else {
                pkgs.addAll(Arrays.asList(knownPkgs));
            }
            pcl.append(new ClassLoader[]{ l });
            try {
                String msl = MODULE_START_LEVEL();
                boolean start = true;
                if (!msl.isEmpty()) {
                    int moduleStartLevel = Integer.parseInt(msl);
                    int level = getBundleStartLevel(b, framework.getBundleContext());
                    start = moduleStartLevel >= level;
                }
                LOG.log(Level.FINE, "Starting bundle {0}: {1}", new Object[] { m.getCodeNameBase(), start });
                if (start) {
                    b.start();
                    if (findCoveredPkgs(exported) && !isResolved(b) && isRealBundle(b)) {
                        throw new IOException("Cannot start " + m.getCodeName() + " state remains INSTALLED after start()"); // NOI18N
                    }
                }
            } catch (BundleException possible) {
                if (isRealBundle(b)) {
                    throw possible;
                }
                // Bundle is a fragment, replace it with host in classloader
                String fragmentHost = b.getHeaders("").get("Fragment-Host");
                Bundle hostBundle = findBundle(fragmentHost);
                if (hostBundle == null) {
                    LOG.log(Level.WARNING, "Failed to locate fragment host bundle {0} for fragment bundle {1}",
                            new Object[]{fragmentHost, m.getCodeNameBase()});
                    throw new IOException("Not found bundle: " + hostBundle);
                }
                l.setBundle(hostBundle);
                LOG.log(Level.FINE, "Not starting fragment {0}, using host bundle {1} for classloading instead", 
                        new Object[]{m.getCodeNameBase(), fragmentHost});
            }
            return pkgs;
        } catch (BundleException ex) {
            throw new IOException("Cannot start " + jar, ex);
        }
    }
    private static boolean isResolved(Bundle b) {
        if (b.getState() == Bundle.INSTALLED) {
            // try to ask for a known resource which is known to resolve 
            // the bundle
            b.findEntries("META-INF", "MANIFEST.MF", false); // NOI18N
        }
        return b.getState() != Bundle.INSTALLED;
    }

    private static boolean isRealBundle(Bundle b) {
        return b.getHeaders("").get("Fragment-Host") == null; // NOI18N
    }

    @Override
    protected void stopLoader(ModuleInfo m, ClassLoader loader) {
        NetigsoLoader nl = (NetigsoLoader)loader;
        Bundle b = nl.getBundle();
        try {
            assert b != null;
            try {
                LOG.log(Level.FINE, "Stopping bundle {0}", m.getCodeNameBase());
                b.stop();
            } catch (BundleException possible) {
                if (isRealBundle(b)) {
                    throw possible;
                }
                LOG.log(Level.FINE, "Not stopping fragment {0}", m.getCodeNameBase());
            }
        } catch (BundleException ex) {
            throw new IllegalStateException(ex);
        }
    }

    @Override
    protected Enumeration<URL> findResources(Module m, String resName) {
        Bundle b = findBundle(m.getCodeNameBase());
        URL u = b.getEntry(resName);
        return u == null ? Enumerations.<URL>empty() : Enumerations.singleton(u);
    }

    @Override
    protected void reload(Module m) throws IOException {
        try {
            Bundle b = findBundle(m.getCodeNameBase());
            b.stop();
            fakeOneModule(m, b);
        } catch (BundleException ex) {
            throw new IOException(ex);
        }
    }

    //
    // take care about the registered bundles
    //
    private final Map<String,String[]> registered = new HashMap<String,String[]>();

    private static final RequestProcessor RP = new RequestProcessor("Netigso Events"); // NOI18N
    final void notifyBundleChange(final String symbolicName, final Version version, final int action) {
        final Exception stack = Netigso.LOG.isLoggable(Level.FINER) ? new Exception("StackTrace") : null;
        final Runnable doLog = new Runnable() {
            @Override
            public void run() {
                if (isEnabled(symbolicName)) {
                    return;
                }
                final Mutex mutex = Main.getModuleSystem().getManager().mutex();
                if (!mutex.isReadAccess()) {
                    mutex.postReadRequest(this);
                    return;
                }
                String type = "" + action;
                Level notify = Level.INFO;
                switch (action) {
                    case BundleEvent.INSTALLED:
                        return; // no message for installed
                    case BundleEvent.RESOLVED:
                        type = "resolved";
                        break;
                    case BundleEvent.STARTED:
                        type = "started";
                        break;
                    case BundleEvent.STOPPED:
                        type = "stopped";
                        break;
                    case BundleEvent.UNINSTALLED:
                        return; // nothing for uninstalled
                    case BundleEvent.LAZY_ACTIVATION:
                        type = "lazy";
                        notify = Level.FINEST;
                        break;
                    case BundleEvent.STARTING:
                        type = "starting";
                        notify = Level.FINEST;
                        break;
                }
                Netigso.LOG.log(notify, "bundle {0}@{2} {1}", new Object[]{
                            symbolicName, type, version
                        });
                if (stack != null) {
                    Netigso.LOG.log(Level.FINER, null, stack);
                }
            }
        };
        RP.post(doLog);
    }

    private File getNetigsoCache() throws IllegalStateException {
        // Explicitly specify the directory to use for caching bundles.
        return Places.getCacheSubdirectory("netigso");
    }

    private void deleteRec(File dir) {
        File[] arr = dir.listFiles();
        if (arr != null) {
            for (File f : arr) {
                deleteRec(f);
            }
        }
        dir.delete();
    }

    private void fakeOneModule(Module m, Bundle original) throws IOException {
        String cnb = m.getCodeNameBase();
        if (registered.get(cnb) != null && original == null) {
            return;
        }
        registered.put(cnb, EMPTY);
        Bundle b;
        try {
            String symbolicName = (String) m.getAttribute("Bundle-SymbolicName");
            if ("org.netbeans.core.osgi".equals(symbolicName)) { // NOI18N
                // Always ignore.
            } else if (symbolicName != null) { // NOI18N
                if (original != null) {
                    LOG.log(Level.FINE, "Updating bundle {0}", original.getLocation());
                    FileInputStream is = new FileInputStream(m.getJarFile());
                    original.update(is);
                    is.close();
                    b = original;
                } else {
                    BundleContext bc = framework.getBundleContext();
                    File jar = m.getJarFile();
                    String loc;
                    if (m.isReloadable()) {
                        loc = toURI(jar);
                    } else {
                        loc = "reference:" + toURI(jar); // NOI18N
                    }
                    LOG.log(Level.FINE, "Installing bundle {0}", loc);
                    b = bc.installBundle(loc);
                    int startLevel = m.getStartLevel();
                    if (startLevel == -1) {
                        startLevel = defaultStartLevel();
                    }
                    if (startLevel > 0) {
                        setBundleStartLevel(bc, b, startLevel);
                    }
                }
            } else {
                InputStream is = fakeBundle(m);
                if (is != null) {
                    if (original != null) {
                        original.update(is);
                        b = original;
                    } else {
                        assert framework != null;
                        BundleContext bc = framework.getBundleContext();
                        assert bc != null;
                        b = bc.installBundle("netigso://" + cnb, is);
                    }
                    is.close();
                }
            }
            Stamps.getModulesJARs().scheduleSave(this, "netigso-bundles", false); // NOI18N
        } catch (BundleException ex) {
            throw new IOException(ex);
        }
    }

    private void setFrameworkStartLevel(BundleContext bc, int startLevel) {
        ServiceReference sr = bc.getServiceReference("org.osgi.service.startlevel.StartLevel"); // NOI18N
        StartLevel level = null;
        if (sr != null) {
            level = (StartLevel) bc.getService(sr);
            if (level != null) {
                level.setStartLevel(startLevel);
                return;
            }
        }
        LOG.log(
            Level.WARNING, 
            "Cannot set framewok startLevel to {1} reference: {2} level {3}", 
            new Object[]{null, startLevel, sr, level}
        );
    }
    private void setBundleStartLevel(BundleContext bc, Bundle b, int startLevel) {
        ServiceReference sr = bc.getServiceReference("org.osgi.service.startlevel.StartLevel"); // NOI18N
        StartLevel level = null;
        if (sr != null) {
            level = (StartLevel) bc.getService(sr);
            if (level != null) {
                level.setBundleStartLevel(b, startLevel);
                return;
            }
        }
        LOG.log(
            Level.WARNING, 
            "Cannot set startLevel for {0} to {1} reference: {2} level {3}", 
            new Object[]{b.getSymbolicName(), startLevel, sr, level}
        );
    }
    
    private int getBundleStartLevel(Bundle b, BundleContext bc) {
        ServiceReference sr = bc.getServiceReference("org.osgi.service.startlevel.StartLevel"); // NOI18N
        StartLevel level = null;
        if (sr != null) {
            level = (StartLevel) bc.getService(sr);
            if (level != null) {
                return level.getBundleStartLevel(b);
            }
        }
        return 0;
    }

    
    private static String threeDotsWithMajor(String version, String withMajor) {
        int indx = withMajor.indexOf('/');
        int major = 0;
        if (indx > 0) {
            major = Integer.parseInt(withMajor.substring(indx + 1));
        }
        String[] segments = (version + ".0.0.0").split("\\.");
        assert segments.length >= 3 && segments[0].length() > 0;

        return (Integer.parseInt(segments[0]) + major * 100) + "."  + segments[1] + "." + segments[2];
    }

    /** Creates a fake bundle definition that represents one NetBeans module
     *
     * @param m the module
     * @return the stream to read the definition from or null, if it does not
     *   make sense to represent this module as bundle
     */
    private static InputStream fakeBundle(Module m) throws IOException {
        String netigsoExp = (String) m.getAttribute("Netigso-Export-Package"); // NOI18N
        String exp = (String) m.getAttribute("OpenIDE-Module-Public-Packages"); // NOI18N
        if (netigsoExp == null) {
            if ("-".equals(exp) || m.getAttribute("OpenIDE-Module-Friends") != null) { // NOI18N
                return null;
            }
        }
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        Manifest man = new Manifest();
        man.getMainAttributes().putValue("Manifest-Version", "1.0"); // workaround for JDK bug
        man.getMainAttributes().putValue("Bundle-ManifestVersion", "2"); // NOI18N
        man.getMainAttributes().putValue("Bundle-SymbolicName", m.getCodeNameBase()); // NOI18N

        if (m.getSpecificationVersion() != null) {
            String spec = threeDotsWithMajor(m.getSpecificationVersion().toString(), m.getCodeName());
            man.getMainAttributes().putValue("Bundle-Version", spec.toString()); // NOI18N
        }
        if (netigsoExp != null) {
            man.getMainAttributes().putValue("Export-Package", netigsoExp); // NOI18N
        } else if (exp != null) {
            man.getMainAttributes().putValue("Export-Package", substitutePkg(m)); // NOI18N
        } else {
            man.getMainAttributes().putValue("Export-Package", m.getCodeNameBase()); // NOI18N
        }        
        JarOutputStream jos = new JarOutputStream(os, man);
        jos.close();
        return new ByteArrayInputStream(os.toByteArray());
    }

    private void readBundles() {
        assert registered.isEmpty();
        try {
            InputStream is = Stamps.getModulesJARs().asStream("netigso-bundles");
            if (is == null) {
                File f;
                try {
                    f = getNetigsoCache();
                } catch (IllegalStateException ex) {
                    return;
                }
                deleteRec(f);
                return;
            }
            Properties p = new Properties();
            p.load(is);
            is.close();
            for (Map.Entry<Object, Object> entry : p.entrySet()) {
                String k = (String)entry.getKey();
                String v = (String)entry.getValue();
                registered.put(k, v.trim().isEmpty() ? EMPTY : v.split(","));
                LOG.log(Level.FINE, "readBundle: {0}", k);
            }
        } catch (IOException ex) {
            LOG.log(Level.WARNING, "Cannot read cache", ex);
        }
    }

    @Override
    public void flushCaches(DataOutputStream os) throws IOException {
        Properties p = new Properties();
        for (Map.Entry<String, String[]> entry : registered.entrySet()) {
            StringBuilder sb = new StringBuilder();
            String sep = "";
            for (String s : entry.getValue()) {
                sb.append(sep);
                sb.append(s);
                sep = ",";
            }
            p.setProperty(entry.getKey(), sb.toString());
        }

        p.store(os, null);
    }

    @Override
    public void cacheReady() {
    }

    private Bundle findBundle(String codeNameBase) {
        for (Bundle bb : framework.getBundleContext().getBundles()) {
            final String bbName = bb.getSymbolicName().replace('-', '_');
            if (bbName.equals(codeNameBase)) {
                return bb;
            }
        }
        return null;
    }

    public byte[] fromArchive(long bundleId, String resource, ArchiveResources ar) throws IOException {
        if (SELF_QUERY.get()) {
            return ar.resource(resource);
        }
        return fromArchive(ar, resource);
    }

    public boolean isArchiveActive() {
        return !SELF_QUERY.get();
    }

    private static String toURI(final File file) {
        class VFile extends File {

            public VFile() {
                super(file.getPath());
            }

            @Override
            public boolean isDirectory() {
                return false;
            }

            @Override
            public File getAbsoluteFile() {
                return this;
            }
        }
        return Utilities.toURI(new VFile()).toString();
    }

    @Messages({"#NOI18N", "FIND_COVERED_PKGS=findEntries"})
    private boolean findCoveredPkgs(Object exportedPackages) {
        if (defaultCoveredPkgs == null) {
            defaultCoveredPkgs = FIND_COVERED_PKGS();
        }
        if ("exportedIfPresent".equals(defaultCoveredPkgs)) { // NOI18N
            return exportedPackages == null;
        }
        
        return "findEntries".equals(defaultCoveredPkgs); // NOI18N
    }

    final ClassLoader findClassLoader(String cnb) {
        return createClassLoader(cnb);
    }
    private boolean isEnabled(String cnd) {
        Module m = findModule(cnd);
        return m != null && m.isEnabled();
    }
    private static String substitutePkg(Module m) {
        StringBuilder exported = new StringBuilder();
        String sep = "";
        PackageExport[] pblk = m.getPublicPackages();
        if (pblk == null) {
            pblk = new PackageExport[1];
            pblk[0] = new PackageExport("", true);
        }
        
        for (Module.PackageExport packageExport : pblk) {
            Set<String> pkgs;
            if (packageExport.recursive) {
                pkgs = findRecursivePkgs(m, packageExport);
            } else {
                pkgs = Collections.singleton(packageExport.pkg);
            }
            for (String p : pkgs) {
                if (p.endsWith("/")) { // NOI18N
                    p = p.substring(0, p.length() - 1);
                }
                exported.append(sep).append(p.replace('/', '.'));
                sep = ",";
            }
        }
        if (exported.length() == 0) {
            exported.append(m.getCodeNameBase());
        }
        return exported.toString();
    }
    private static Set<String> findRecursivePkgs(Module m, PackageExport packageExport)  {
        Set<String> pkgs = new HashSet<String>();
        for (File f : m.getAllJars()) {
            JarFile jf = null;
            try {
                jf = new JarFile(f);
                Enumeration<JarEntry> en = jf.entries();
                while (en.hasMoreElements()) {
                    JarEntry e = en.nextElement();
                    if (e.isDirectory()) {
                        continue;
                    }
                    final String entryName = e.getName();
                    int lastSlash = entryName.lastIndexOf('/');
                    if (lastSlash == -1) {
                        continue;
                    }
                    String pkg = entryName.substring(0, lastSlash + 1);
                    if (pkg.startsWith(packageExport.pkg)) {
                        pkgs.add(pkg);
                    }
                }
            } catch (IOException ex) {
                LOG.log(Level.INFO, "Can't process " + f, ex);
            } finally {
                try {
                    jf.close();
                } catch (IOException ex) {
                    LOG.log(Level.INFO, "Can't close " + f, ex);
                }
            }
        }
        return pkgs;
    }

    public final byte[] patchBC(ClassLoader l, String className, ProtectionDomain pd, byte[] arr) {
        return patchByteCode(l, className, pd, arr);
    }
}
