/*
 * Decompiled with CFR 0.152.
 */
package com.tridium.sys.module;

import com.tridium.asm.Buffer;
import com.tridium.sys.module.ModuleExtClassLoader;
import com.tridium.sys.module.NModule;
import com.tridium.util.jar.JarEntry;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLConnection;
import java.security.AllPermission;
import java.security.CodeSource;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.SecureClassLoader;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;
import javax.baja.spy.Spy;
import javax.baja.spy.SpyWriter;

/*
 * Illegal identifiers - consider using --renameillegalidents true
 */
public class ModuleClassLoader
extends SecureClassLoader {
    private static final DecimalFormat DF = new DecimalFormat("###,###,###");
    static final boolean legacyExtClassLoader = Boolean.getBoolean("niagara.classLoader.ext");
    static final boolean parallelCapableClassLoader = Boolean.getBoolean("niagara.classLoader.parallelCapable");
    static final Object NOT_FOUND;
    private static final Map spyMap;
    public final NModule module;
    private Hashtable cache;
    private Buffer buffer;
    protected CodeSource codeSource;
    private Permissions permissions;
    private Hashtable extClassLoadersByResourcePath;
    static /* synthetic */ Class class$java$lang$String;
    static /* synthetic */ Class class$java$lang$ClassLoader;

    public Class loadClass(String string, boolean bl) throws ClassNotFoundException {
        Class clazz = this.nload(string, bl);
        if (clazz == null) {
            String string2 = string;
            if (this.module != null) {
                string2 = this.module.name + ':' + string;
            }
            throw new ClassNotFoundException(string2);
        }
        return clazz;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     */
    public Class nload(String string, boolean bl) {
        Object object = ModuleClassLoader.getLoadClassLock(this, string);
        Object object2 = object;
        synchronized (object2) {
            Object v = this.cache.get(string);
            if (v == NOT_FOUND) {
                return null;
            }
            Class clazz = (Class)v;
            if (clazz == null) {
                clazz = this.nfind(string, bl);
                if (clazz == null) {
                    this.cache.put(string, NOT_FOUND);
                    return null;
                }
                this.cache.put(string, clazz);
            }
            if (bl) {
                this.resolveClass(clazz);
            }
            return clazz;
        }
    }

    static final Object getLoadClassLock(ClassLoader classLoader, String string) {
        Object object = classLoader;
        try {
            Method method;
            Class clazz = class$java$lang$ClassLoader;
            if (clazz == null) {
                clazz = class$java$lang$ClassLoader = ModuleClassLoader.class("[Ljava.lang.ClassLoader;", false);
            }
            Class[] classArray = new Class[1];
            Class clazz2 = class$java$lang$String;
            if (clazz2 == null) {
                clazz2 = classArray[0] = (class$java$lang$String = ModuleClassLoader.class("[Ljava.lang.String;", false));
            }
            if ((method = clazz.getDeclaredMethod("getClassLoadingLock", classArray)) != null) {
                object = method.invoke((Object)classLoader, string);
            }
        }
        catch (Throwable throwable) {}
        return object;
    }

    Class defineExtClass(String string, byte[] byArray, int n, int n2, CodeSource codeSource) {
        return this.defineClass(string, byArray, 0, byArray.length, codeSource);
    }

    protected Class nfind(String string, boolean bl) {
        block18: {
            block17: {
                if (string.startsWith("auto.")) {
                    ModuleClassLoader.addClassToSpy(this.module.name, string, this.buffer.count);
                    return this.defineClass(string, this.buffer.bytes, 0, this.buffer.count, this.codeSource);
                }
                try {
                    return this.getParent().loadClass(string);
                }
                catch (ClassNotFoundException classNotFoundException) {
                    String string2 = string.replace('.', '/') + ".class";
                    ArrayList arrayList = (ArrayList)this.extClassLoadersByResourcePath.get(string2);
                    if (arrayList != null) {
                        return ((ModuleExtClassLoader)arrayList.get(0)).nfind(string, bl, false);
                    }
                    if (this.module.isSynthetic()) break block17;
                    JarEntry jarEntry = this.module.jarFile.getJarEntry(string2);
                    if (jarEntry != null) {
                        byte[] byArray = null;
                        try {
                            int n = (int)jarEntry.getSize();
                            InputStream inputStream = jarEntry.getInputStream();
                            byArray = new byte[n];
                            int n2 = 0;
                            while (n2 < n) {
                                int n3 = inputStream.read(byArray, n2, n - n2);
                                if (n3 < 0) {
                                    throw new IOException("Unexpected EOF");
                                }
                                n2 += n3;
                            }
                            inputStream.close();
                            ModuleClassLoader.addClassToSpy(this.module.name, string, byArray.length);
                            return this.defineClass(string, byArray, 0, byArray.length, this.codeSource);
                        }
                        catch (IOException iOException) {
                            iOException.printStackTrace();
                            return null;
                        }
                    }
                    break block18;
                }
            }
            if (this.module.getTypeClassName(string.substring(string.lastIndexOf(46) + 2)) != null) {
                ModuleClassLoader.addClassToSpy(this.module.name, string, this.buffer.count);
                Class<?> clazz = this.defineClass(string, this.buffer.bytes, 0, this.buffer.count, this.codeSource);
                try {
                    Class.forName(clazz.getName(), true, clazz.getClassLoader());
                }
                catch (ClassNotFoundException classNotFoundException) {}
                return clazz;
            }
        }
        if (this.module.depends != null) {
            Class clazz;
            NModule nModule;
            int n = string.lastIndexOf(46);
            String string3 = n == -1 ? "" : string.substring(0, n);
            int n4 = 0;
            while (n4 < this.module.depends.length) {
                nModule = this.module.depends[n4].resolution;
                if (!nModule.isSystemJar && nModule.containsPackage(string3) && (clazz = nModule.classLoader.nload(string, bl)) != null) {
                    return clazz;
                }
                ++n4;
            }
            n4 = 0;
            while (n4 < this.module.depends.length) {
                nModule = this.module.depends[n4].resolution;
                if (!nModule.isSystemJar && (clazz = nModule.classLoader.nload(string, bl)) != null) {
                    return clazz;
                }
                ++n4;
            }
        }
        return null;
    }

    public URL getResource(String string) {
        URL uRL = this.getResourceImpl(string);
        if (uRL != null) {
            return uRL;
        }
        return ModuleClassLoader.getSystemResource(string);
    }

    private final URL getResourceImpl(String string) {
        ArrayList arrayList = (ArrayList)this.extClassLoadersByResourcePath.get(string);
        if (arrayList != null) {
            return ((ModuleExtClassLoader)arrayList.get(0)).getResourceImpl(string);
        }
        JarEntry jarEntry = this.module.jarFile.getJarEntry(string);
        if (jarEntry != null) {
            return jarEntry.getURL();
        }
        if (this.module.depends != null) {
            int n = 0;
            while (n < this.module.depends.length) {
                URL uRL;
                NModule nModule = this.module.depends[n].resolution;
                if (!nModule.isSystemJar && (uRL = nModule.classLoader.getResourceImpl(string)) != null) {
                    return uRL;
                }
                ++n;
            }
        }
        return null;
    }

    public InputStream getResourceAsStream(String string) {
        try {
            URL uRL = this.getResource(string);
            if (uRL != null) {
                URLConnection uRLConnection = uRL.openConnection();
                uRLConnection.connect();
                return uRLConnection.getInputStream();
            }
        }
        catch (IOException iOException) {
            iOException.printStackTrace();
        }
        return null;
    }

    protected Enumeration findResources(String string) throws IOException {
        ArrayList arrayList = (ArrayList)this.extClassLoadersByResourcePath.get(string);
        Vector<URL> vector = new Vector<URL>();
        if (arrayList != null) {
            Iterator iterator = arrayList.iterator();
            while (iterator.hasNext()) {
                vector.add(((ModuleExtClassLoader)iterator.next()).getResourceImpl(string));
            }
            return vector.elements();
        }
        URL uRL = this.getResourceImpl(string);
        if (uRL != null) {
            vector.add(uRL);
        }
        return vector.elements();
    }

    public PermissionCollection getPermissions(CodeSource codeSource) {
        return this.permissions;
    }

    Class loadAutoClass(String string, Buffer buffer) throws ClassNotFoundException {
        this.buffer = buffer;
        Class<?> clazz = this.loadClass(string);
        this.buffer = null;
        return clazz;
    }

    protected static void addClassToSpy(String string, String string2, int n) {
        int[] nArray = (int[])spyMap.get(string);
        if (nArray == null) {
            nArray = new int[2];
            spyMap.put(string, nArray);
        }
        nArray[0] = nArray[0] + 1;
        nArray[1] = nArray[1] + n;
    }

    public String toString() {
        return this.getClass().getName() + " for " + this.module + " [" + Integer.toString(System.identityHashCode(this), 36) + ']';
    }

    public static void registerAsParallelCapableFix() {
        try {
            Method method;
            Class clazz = class$java$lang$ClassLoader;
            if (clazz == null) {
                clazz = class$java$lang$ClassLoader = ModuleClassLoader.class("[Ljava.lang.ClassLoader;", false);
            }
            if ((method = clazz.getDeclaredMethod("registerAsParallelCapable", null)) != null) {
                method.setAccessible(true);
                Object object = method.invoke(null, null);
            }
        }
        catch (Throwable throwable) {}
    }

    static /* synthetic */ Class class(String string, boolean bl) {
        try {
            Class<?> clazz = Class.forName(string);
            if (!bl) {
                clazz = clazz.getComponentType();
            }
            return clazz;
        }
        catch (ClassNotFoundException classNotFoundException) {
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
        }
    }

    private final /* synthetic */ void this() {
        this.cache = new Hashtable();
        this.extClassLoadersByResourcePath = new Hashtable();
    }

    ModuleClassLoader(NModule nModule) {
        super(nModule.getClass().getClassLoader());
        this.this();
        this.module = nModule;
        URL uRL = null;
        if (nModule.jarFile != null) {
            uRL = nModule.jarFile.getFileURL();
        }
        this.codeSource = new CodeSource(uRL, null);
        this.permissions = new Permissions();
        this.permissions.add(new AllPermission());
        if (nModule.extJars != null) {
            int n = 0;
            while (n < nModule.extJars.length) {
                ModuleExtClassLoader moduleExtClassLoader = new ModuleExtClassLoader(this, nModule.extJars[n], this.codeSource);
                Iterator iterator = nModule.extJars[n].resourcePaths.iterator();
                while (iterator.hasNext()) {
                    String string = (String)iterator.next();
                    ArrayList<ModuleExtClassLoader> arrayList = (ArrayList<ModuleExtClassLoader>)this.extClassLoadersByResourcePath.get(string);
                    if (arrayList == null) {
                        arrayList = new ArrayList<ModuleExtClassLoader>();
                        this.extClassLoadersByResourcePath.put(string, arrayList);
                    }
                    arrayList.add(moduleExtClassLoader);
                }
                ++n;
            }
        }
    }

    static {
        if (parallelCapableClassLoader) {
            ModuleClassLoader.registerAsParallelCapableFix();
        }
        NOT_FOUND = new Object();
        spyMap = new HashMap();
    }

    public static class LoaderSpy
    extends Spy {
        private final void row(SpyWriter spyWriter, String string, int n, int n2) {
            spyWriter.w("<tr>");
            spyWriter.w("<td align='left' nowrap='true'>").w(string).w("</td>");
            spyWriter.w("<td align='right' nowrap='true'>").w(DF.format(n)).w("</td>");
            spyWriter.w("<td align='right' nowrap='true'>").w(DF.format(n2)).w("</td>");
            spyWriter.w("</tr>\n");
        }

        private final void summary(SpyWriter spyWriter, String string, int n) {
            spyWriter.w("<tr>");
            spyWriter.w("<td align='left' nowrap='true'>").w(string).w("</td>");
            spyWriter.w("<td align='right' nowrap='true'>").w(DF.format(n)).w("</td>");
            spyWriter.w("</tr>\n");
        }

        public void write(SpyWriter spyWriter) throws Exception {
            int n = 0;
            int n2 = 0;
            spyWriter.startTable(true);
            spyWriter.w("<tr>");
            spyWriter.thTitle("Class Loader");
            spyWriter.thTitle("Classes");
            spyWriter.thTitle("Bytes Loaded");
            spyWriter.w("</tr>");
            Iterator iterator = spyMap.keySet().iterator();
            while (iterator.hasNext()) {
                String string = (String)iterator.next();
                int[] nArray = (int[])spyMap.get(string);
                this.row(spyWriter, string, nArray[0], nArray[1]);
                n += nArray[0];
                n2 += nArray[1];
            }
            spyWriter.endTable();
            spyWriter.w("<p/>");
            spyWriter.startTable(true);
            spyWriter.trTitle("Summary", 2);
            this.summary(spyWriter, "Total Classes", n);
            this.summary(spyWriter, "Total Bytes Loaded", n2);
            spyWriter.endTable();
        }
    }
}