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

import com.tridium.sys.Nre;
import com.tridium.sys.module.ModuleClassLoader;
import com.tridium.sys.module.NModule;
import com.tridium.sys.schema.ComplexIntrospector;
import com.tridium.sys.schema.EnumIntrospector;
import com.tridium.sys.schema.InterfaceIntrospector;
import com.tridium.sys.schema.NType;
import com.tridium.sys.schema.ObjectIntrospector;
import com.tridium.sys.schema.SchemaManager;
import com.tridium.sys.schema.SimpleIntrospector;
import com.tridium.sys.schema.SingletonIntrospector;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Modifier;
import javax.baja.sys.BObject;
import javax.baja.sys.Type;
import javax.baja.sys.TypeIntrospectionException;

/*
 * Illegal identifiers - consider using --renameillegalidents true
 */
public abstract class Introspector {
    static Class propertyClass;
    static Class actionClass;
    static Class topicClass;
    Class cls;
    int id;
    boolean isAbstract;
    boolean isFinal;
    NModule module;
    String typeName;
    String facetsPath;
    static /* synthetic */ Class class$javax$baja$sys$Property;
    static /* synthetic */ Class class$javax$baja$sys$Action;
    static /* synthetic */ Class class$javax$baja$sys$Topic;
    static /* synthetic */ Class class$javax$baja$sys$BComplex;
    static /* synthetic */ Class class$javax$baja$sys$BFrozenEnum;
    static /* synthetic */ Class class$javax$baja$sys$BSimple;
    static /* synthetic */ Class class$javax$baja$sys$BSingleton;
    static /* synthetic */ Class class$java$lang$Class;
    static /* synthetic */ Class class$com$tridium$sys$schema$Introspector;
    static /* synthetic */ Class class$javax$baja$sys$BObject;

    static Introspector create(int n, Class clazz) {
        if (clazz.isInterface()) {
            return new InterfaceIntrospector(n, clazz);
        }
        Introspector introspector = Introspector.getCustomIntrospector(n, clazz);
        if (introspector != null) {
            return introspector;
        }
        Class clazz2 = class$javax$baja$sys$BComplex;
        if (clazz2 == null) {
            clazz2 = class$javax$baja$sys$BComplex = Introspector.class("[Ljavax.baja.sys.BComplex;", false);
        }
        if (clazz2.isAssignableFrom(clazz)) {
            return new ComplexIntrospector(n, clazz);
        }
        Class clazz3 = class$javax$baja$sys$BFrozenEnum;
        if (clazz3 == null) {
            clazz3 = class$javax$baja$sys$BFrozenEnum = Introspector.class("[Ljavax.baja.sys.BFrozenEnum;", false);
        }
        if (clazz3.isAssignableFrom(clazz)) {
            return new EnumIntrospector(n, clazz);
        }
        Class clazz4 = class$javax$baja$sys$BSimple;
        if (clazz4 == null) {
            clazz4 = class$javax$baja$sys$BSimple = Introspector.class("[Ljavax.baja.sys.BSimple;", false);
        }
        if (clazz4.isAssignableFrom(clazz)) {
            return new SimpleIntrospector(n, clazz);
        }
        Class clazz5 = class$javax$baja$sys$BSingleton;
        if (clazz5 == null) {
            clazz5 = class$javax$baja$sys$BSingleton = Introspector.class("[Ljavax.baja.sys.BSingleton;", false);
        }
        if (clazz5.isAssignableFrom(clazz)) {
            return new SingletonIntrospector(n, clazz);
        }
        return new ObjectIntrospector(n, clazz);
    }

    static Introspector getCustomIntrospector(int n, Class clazz) {
        try {
            Field field = Introspector.getField("INTROSPECTOR", clazz);
            if (field == null) {
                return null;
            }
            Class clazz2 = class$java$lang$Class;
            if (clazz2 == null) {
                clazz2 = class$java$lang$Class = Introspector.class("[Ljava.lang.Class;", false);
            }
            if (!clazz2.isAssignableFrom(field.getType())) {
                return null;
            }
            Class clazz3 = (Class)field.get(null);
            Class clazz4 = class$com$tridium$sys$schema$Introspector;
            if (clazz4 == null) {
                clazz4 = class$com$tridium$sys$schema$Introspector = Introspector.class("[Lcom.tridium.sys.schema.Introspector;", false);
            }
            if (!clazz4.isAssignableFrom(clazz3)) {
                return null;
            }
            Class[] classArray = new Class[2];
            classArray[0] = Integer.TYPE;
            Class clazz5 = class$java$lang$Class;
            if (clazz5 == null) {
                clazz5 = class$java$lang$Class = Introspector.class("[Ljava.lang.Class;", false);
            }
            classArray[1] = clazz5;
            Constructor constructor = clazz3.getConstructor(classArray);
            return (Introspector)constructor.newInstance(new Integer(n), clazz);
        }
        catch (Exception exception) {
            exception.printStackTrace();
            return null;
        }
    }

    /*
     * Unable to fully structure code
     */
    static Field getField(String var0, Class var1_1) {
        var2_2 = var1_1;
        if (true) ** GOTO lbl11
        do {
            var3_3 = null;
            try {
                var3_3 = var2_2.getDeclaredField(var0);
                var3_3.setAccessible(true);
                return var3_3;
            }
            catch (Exception var4_4) {
                var2_2 = var2_2.getSuperclass();
            }
lbl11:
            // 2 sources

            if ((v0 = Introspector.class$javax$baja$sys$BObject) != null) continue;
            v0 = Introspector.class("[Ljavax.baja.sys.BObject;", false);
        } while (var2_2 != v0);
        return null;
    }

    abstract Type introspect() throws Exception;

    BObject getConstantFieldObject(String string) throws Exception {
        try {
            if (this.isAbstract) {
                return null;
            }
            Field field = this.cls.getField(string);
            this.checkPublicStaticFinal(field);
            if (field.getType() != this.cls) {
                throw this.err(string + " field is wrong type");
            }
            BObject bObject = (BObject)field.get(null);
            if (bObject == null) {
                throw this.err(string + " field is null; insure getType() comes last");
            }
            return bObject;
        }
        catch (TypeIntrospectionException typeIntrospectionException) {
            throw typeIntrospectionException;
        }
        catch (Exception exception) {
            throw this.err("Missing or invalid " + string + " field");
        }
    }

    NModule getModule() {
        return Introspector.getModule(this.cls, this.typeName);
    }

    static NModule getModule(Class clazz, String string) {
        ClassLoader classLoader = clazz.getClassLoader();
        if (classLoader instanceof ModuleClassLoader) {
            NModule nModule = ((ModuleClassLoader)classLoader).module;
            String string2 = nModule.getTypeClassName(string);
            if (string2 == null) {
                throw Introspector.err(clazz, "Module does not declare type '" + string + "' in 'module.xml'");
            }
            if (!string2.equals(clazz.getName())) {
                throw Introspector.err(clazz, "Type '" + string + "' should be '" + string2 + '\'');
            }
            return nModule;
        }
        NModule[] nModuleArray = Nre.moduleManager.getModules();
        int n = 0;
        while (n < nModuleArray.length) {
            String string3;
            if (nModuleArray[n].isSystemJar() && (string3 = nModuleArray[n].getTypeClassName(string)) != null && string3.equals(clazz.getName())) {
                return nModuleArray[n];
            }
            ++n;
        }
        throw Introspector.err(clazz, "Cannot resolve class to module (check 'module.xml')");
    }

    boolean isPublic(Member member) {
        return Modifier.isPublic(member.getModifiers());
    }

    boolean isStatic(Member member) {
        return Modifier.isStatic(member.getModifiers());
    }

    boolean isPublicStaticFinal(Field field) {
        int n = field.getModifiers();
        boolean bl = false;
        if (Modifier.isPublic(n) && Modifier.isStatic(n) && Modifier.isFinal(n)) {
            bl = true;
        }
        return bl;
    }

    void checkPublicStaticFinal(Field field) {
        if (!this.isPublicStaticFinal(field)) {
            throw this.err("Field must be public static final", field.getName());
        }
    }

    public TypeIntrospectionException err(String string) {
        return Introspector.err(this.cls, string);
    }

    public static TypeIntrospectionException err(Class clazz, String string) {
        return Introspector.err(clazz, string, null);
    }

    public TypeIntrospectionException err(String string, String string2) {
        return Introspector.err(this.cls, string, string2);
    }

    public static TypeIntrospectionException err(Class clazz, String string, String string2) {
        String string3 = string2 == null ? string : string + " (" + string2 + ')';
        String string4 = clazz.getName();
        if (clazz.getClassLoader() instanceof ModuleClassLoader) {
            NModule nModule = ((ModuleClassLoader)clazz.getClassLoader()).module;
            string4 = nModule.getModuleName() + ':' + string4;
        }
        SchemaManager.log.error(string4 + ": " + string3);
        return new TypeIntrospectionException(clazz, string3);
    }

    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());
        }
    }

    protected Introspector(int n, Class clazz) {
        this.id = n;
        this.cls = clazz;
        this.typeName = NType.getTypeName(clazz.getName());
        this.module = this.getModule();
        this.facetsPath = "/" + clazz.getName().replace('.', '/') + ".facets";
        this.isAbstract = Modifier.isAbstract(clazz.getModifiers());
        this.isFinal = Modifier.isFinal(clazz.getModifiers());
    }

    static {
        Class clazz;
        Class clazz2;
        Class clazz3 = class$javax$baja$sys$Property;
        if (clazz3 == null) {
            clazz3 = propertyClass = (class$javax$baja$sys$Property = Introspector.class("[Ljavax.baja.sys.Property;", false));
        }
        if ((clazz2 = class$javax$baja$sys$Action) == null) {
            clazz2 = actionClass = (class$javax$baja$sys$Action = Introspector.class("[Ljavax.baja.sys.Action;", false));
        }
        if ((clazz = class$javax$baja$sys$Topic) == null) {
            clazz = class$javax$baja$sys$Topic = Introspector.class("[Ljavax.baja.sys.Topic;", false);
        }
        topicClass = clazz;
    }
}