/*
 * Decompiled with CFR 0.152.
 */
package javax.baja.sys;

import com.tridium.sys.schema.ComplexSlotMap;
import com.tridium.sys.schema.ComplexType;
import com.tridium.sys.schema.ComponentSlotMap;
import com.tridium.sys.schema.NProperty;
import java.util.HashMap;
import javax.baja.naming.SlotPath;
import javax.baja.security.BPermissions;
import javax.baja.spy.SpyWriter;
import javax.baja.sys.Action;
import javax.baja.sys.BBoolean;
import javax.baja.sys.BComponent;
import javax.baja.sys.BDouble;
import javax.baja.sys.BFacets;
import javax.baja.sys.BFloat;
import javax.baja.sys.BIMixIn;
import javax.baja.sys.BInteger;
import javax.baja.sys.BLong;
import javax.baja.sys.BObject;
import javax.baja.sys.BString;
import javax.baja.sys.BValue;
import javax.baja.sys.BasicContext;
import javax.baja.sys.Context;
import javax.baja.sys.CopyHints;
import javax.baja.sys.Flags;
import javax.baja.sys.Knob;
import javax.baja.sys.NoSuchSlotException;
import javax.baja.sys.Property;
import javax.baja.sys.Slot;
import javax.baja.sys.SlotCursor;
import javax.baja.sys.Subscriber;
import javax.baja.sys.Sys;
import javax.baja.sys.Topic;
import javax.baja.sys.Type;
import javax.baja.sys.TypeIntrospectionException;
import javax.baja.util.BFacetsMap;
import javax.baja.util.BFormat;
import javax.baja.util.BNameMap;

/*
 * Illegal identifiers - consider using --renameillegalidents true
 */
public abstract class BComplex
extends BValue {
    private static CopyHints copyHintsDefault = new CopyHints();
    private static CopyHints copyHintsExact = new CopyHints();
    public static final Type TYPE;
    ComplexSlotMap slotMap;
    static /* synthetic */ Class class$javax$baja$sys$BComplex;

    public final String getName() {
        return this.slotMap.getName();
    }

    public final String getDisplayName(Context context) {
        return this.slotMap.getDisplayName(context);
    }

    public String getDisplayName(Slot slot, Context context) {
        BValue bValue;
        BFormat bFormat;
        BValue bValue2 = this.get("displayNames");
        if (bValue2 instanceof BNameMap && (bFormat = (bValue = (BNameMap)bValue2).get(slot.getName())) != null) {
            return bFormat.format(null, context);
        }
        if (slot.isDynamic() && (bValue = this.get((Property)slot)) instanceof BIMixIn) {
            return ((BIMixIn)((Object)bValue)).getDisplayNameInParent(context);
        }
        return slot.getDefaultDisplayName(context);
    }

    public final BComplex getParent() {
        return this.slotMap.getParent();
    }

    public final Property getPropertyInParent() {
        return this.slotMap.getPropertyInParent();
    }

    public final BComponent getParentComponent() {
        BComplex bComplex = this;
        while (!bComplex.isComponent()) {
            if ((bComplex = bComplex.getParent()) != null) continue;
            return null;
        }
        return bComplex.asComponent();
    }

    public final Property getPropertyInParentComponent() {
        if (this.isComponent() || this.getParent() == null) {
            return null;
        }
        BComplex bComplex = this;
        while (!bComplex.getParent().isComponent()) {
            if ((bComplex = bComplex.getParent()).getParent() != null) continue;
            return null;
        }
        return bComplex.getPropertyInParent();
    }

    public final synchronized BValue newCopy() {
        return this.slotMap.newCopy(copyHintsDefault, BComplex.copySerialNum());
    }

    public final synchronized BValue newCopy(boolean bl) {
        return this.slotMap.newCopy(bl ? copyHintsExact : copyHintsDefault, BComplex.copySerialNum());
    }

    public final synchronized BValue newCopy(CopyHints copyHints) {
        return this.slotMap.newCopy(copyHints, BComplex.copySerialNum());
    }

    public final void copyFrom(BComplex bComplex, Context context) {
        this.slotMap.copyFrom(bComplex.slotMap, context);
    }

    public final void copyFrom(BComplex bComplex) {
        this.slotMap.copyFrom(bComplex.slotMap, Context.copying);
    }

    public final int hashCode() {
        return super.hashCode();
    }

    public final boolean equals(Object object) {
        boolean bl = false;
        if (this == object) {
            bl = true;
        }
        return bl;
    }

    public synchronized boolean equivalent(Object object) {
        if (object == null) {
            return false;
        }
        if (object.getClass() != this.getClass()) {
            return false;
        }
        return this.slotMap.equivalent(((BComplex)object).slotMap);
    }

    public final void setFacets(Slot slot, BFacets bFacets) {
        this.setFacets(slot, bFacets, null);
    }

    public final void setFacets(Slot slot, BFacets bFacets, Context context) {
        if (slot.isFrozen()) {
            BComplex bComplex = this;
            BComponent bComponent = null;
            StringBuffer stringBuffer = new StringBuffer();
            while (!bComplex.isComponent()) {
                stringBuffer.insert(0, '/');
                stringBuffer.insert(0, bComplex.getName());
                bComplex = bComplex.getParent();
                if (bComplex == null) break;
            }
            if (bComplex != null) {
                bComponent = bComplex.asComponent();
            }
            if (bComponent != null && bComponent instanceof BComponent) {
                BFacetsMap bFacetsMap = (BFacetsMap)bComponent.get("slotFacets_");
                HashMap<String, BFacets> hashMap = new HashMap<String, BFacets>();
                if (bFacetsMap != null) {
                    String[] stringArray = bFacetsMap.list();
                    int n = 0;
                    while (n < stringArray.length) {
                        hashMap.put(stringArray[n], bFacetsMap.get(stringArray[n]));
                        ++n;
                    }
                }
                if (bFacets.isNull()) {
                    hashMap.remove(stringBuffer.toString() + slot.getName());
                } else {
                    hashMap.put(stringBuffer.toString() + slot.getName(), BFacets.makeRemove(bFacets, slot.getFacets().list()));
                }
                if (hashMap.size() == 0) {
                    if (bFacetsMap != null) {
                        bComponent.remove("slotFacets_", context);
                    }
                } else {
                    boolean bl = false;
                    if (bFacetsMap == null) {
                        bl = true;
                    }
                    boolean bl2 = bl;
                    bFacetsMap = BFacetsMap.make(hashMap);
                    if (bl2) {
                        bComponent.add("slotFacets_", bFacetsMap, 4, context);
                    } else {
                        bComponent.set("slotFacets_", (BValue)bFacetsMap, context);
                    }
                }
            }
        } else {
            this.slotMap.setFacets(slot, bFacets, context);
        }
    }

    public BFacets getSlotFacets(Slot slot) {
        if (slot.isFrozen()) {
            BFacets bFacets;
            BFacetsMap bFacetsMap;
            BComplex bComplex = this;
            BComponent bComponent = null;
            StringBuffer stringBuffer = new StringBuffer();
            while (!bComplex.isComponent()) {
                stringBuffer.insert(0, '/');
                stringBuffer.insert(0, bComplex.getName());
                bComplex = bComplex.getParent();
                if (bComplex == null) break;
            }
            if (bComplex != null) {
                bComponent = bComplex.asComponent();
            }
            if (bComponent != null && (bFacetsMap = (BFacetsMap)bComponent.get("slotFacets_")) != null && (bFacets = bFacetsMap.get(stringBuffer.toString() + slot.getName())) != null) {
                return BFacets.make(bFacets, slot.getFacets());
            }
        }
        return slot.getFacets();
    }

    public String propertyValueToString(Property property, Context context) {
        BFacets bFacets = this.getSlotFacets(property);
        if (context == null) {
            context = bFacets;
        } else if (!bFacets.isNull()) {
            context = new BasicContext(context, bFacets);
        }
        return this.get(property).toString(context);
    }

    public final BComplex loadSlots() {
        this.slotMap.loadSlots();
        return this;
    }

    public final Slot getSlot(String string) {
        return this.slotMap.getSlot(string);
    }

    public final Property getProperty(String string) {
        return (Property)this.slotMap.getSlot(string);
    }

    public final Action getAction(String string) {
        return (Action)this.slotMap.getSlot(string);
    }

    public final Topic getTopic(String string) {
        return (Topic)this.slotMap.getSlot(string);
    }

    public final int getSlotCount() {
        return this.slotMap.getSlotCount();
    }

    public final int getSlotCount(Class clazz) {
        int n = 0;
        SlotCursor slotCursor = this.getProperties();
        while (slotCursor.next(clazz)) {
            ++n;
        }
        return n;
    }

    public final Slot[] getSlotsArray() {
        return this.slotMap.getSlotsArray();
    }

    public final SlotCursor getSlots() {
        return this.slotMap.getSlots();
    }

    public final Property[] getPropertiesArray() {
        return this.slotMap.getPropertiesArray();
    }

    public final Property[] getFrozenPropertiesArray() {
        return this.slotMap.getFrozenPropertiesArray();
    }

    public final Property[] getDynamicPropertiesArray() {
        return this.slotMap.getDynamicPropertiesArray();
    }

    public final SlotCursor getProperties() {
        return this.slotMap.getProperties();
    }

    public final Action[] getActionsArray() {
        return this.slotMap.getActionsArray();
    }

    public final SlotCursor getActions() {
        return this.slotMap.getActions();
    }

    public final Topic[] getTopicsArray() {
        return this.slotMap.getTopicsArray();
    }

    public final SlotCursor getTopics() {
        return this.slotMap.getTopics();
    }

    public final BValue get(Property property) {
        return this.slotMap.get(property);
    }

    public final boolean getBoolean(Property property) {
        return this.slotMap.getBoolean(property);
    }

    public final int getInt(Property property) {
        return this.slotMap.getInt(property);
    }

    public final long getLong(Property property) {
        return this.slotMap.getLong(property);
    }

    public final float getFloat(Property property) {
        return this.slotMap.getFloat(property);
    }

    public final double getDouble(Property property) {
        return this.slotMap.getDouble(property);
    }

    public final String getString(Property property) {
        return this.slotMap.getString(property);
    }

    public final BValue get(String string) {
        return this.slotMap.get(string);
    }

    public final void set(Property property, BValue bValue, Context context) {
        BValue bValue2 = this.get(property);
        ComplexSlotMap complexSlotMap = bValue2 == null ? null : bValue2.getSlotMap();
        this.slotMap.set(property, bValue2, complexSlotMap, bValue, bValue.getSlotMap(), context);
    }

    public final void set(Property property, BValue bValue) {
        this.set(property, bValue, null);
    }

    public final void setBoolean(Property property, boolean bl, Context context) {
        this.slotMap.setBoolean(property, bl, context);
    }

    public final void setInt(Property property, int n, Context context) {
        this.slotMap.setInt(property, n, context);
    }

    public final void setLong(Property property, long l, Context context) {
        this.slotMap.setLong(property, l, context);
    }

    public final void setFloat(Property property, float f, Context context) {
        this.slotMap.setFloat(property, f, context);
    }

    public final void setDouble(Property property, double d, Context context) {
        this.slotMap.setDouble(property, d, context);
    }

    public final void setString(Property property, String string, Context context) {
        this.slotMap.setString(property, string, context);
    }

    public final void setBoolean(Property property, boolean bl) {
        this.slotMap.setBoolean(property, bl, null);
    }

    public final void setInt(Property property, int n) {
        this.slotMap.setInt(property, n, null);
    }

    public final void setLong(Property property, long l) {
        this.slotMap.setLong(property, l, null);
    }

    public final void setFloat(Property property, float f) {
        this.slotMap.setFloat(property, f, null);
    }

    public final void setDouble(Property property, double d) {
        this.slotMap.setDouble(property, d, null);
    }

    public final void setString(Property property, String string) {
        this.slotMap.setString(property, string, null);
    }

    public final void set(String string, BValue bValue) {
        Property property = this.getProperty(string);
        if (property == null) {
            throw new NoSuchSlotException(string);
        }
        this.set(property, bValue);
    }

    public final void set(String string, BValue bValue, Context context) {
        Property property = this.getProperty(string);
        if (property == null) {
            throw new NoSuchSlotException("No such slot: " + string);
        }
        this.set(property, bValue, context);
    }

    public final int getFlags(Slot slot) {
        return this.slotMap.getFlags(slot);
    }

    public final void setFlags(Slot slot, int n) {
        this.slotMap.setFlags(slot, n, null);
    }

    public final void setFlags(Slot slot, int n, Context context) {
        this.slotMap.setFlags(slot, n, context);
    }

    public void spy(SpyWriter spyWriter) throws Exception {
        spyWriter.startProps();
        this.spyProperties(spyWriter);
        this.spyActions(spyWriter);
        this.spyTopics(spyWriter);
        this.spyKnobs(spyWriter);
        this.spySubscribers(spyWriter);
        this.spySpaceNode(spyWriter);
        this.spyDebug(spyWriter);
        spyWriter.endProps();
    }

    void spyProperties(SpyWriter spyWriter) {
        this.loadSlots();
        BComponent bComponent = (BComponent)this;
        BPermissions bPermissions = bComponent.getPermissions(spyWriter.getContext());
        SlotCursor slotCursor = this.getProperties();
        boolean bl = true;
        while (slotCursor.next()) {
            Property property = slotCursor.property();
            BObject bObject = slotCursor.get();
            boolean bl2 = false;
            if (!bPermissions.hasAdminRead() && bPermissions.hasOperatorRead()) {
                if ((bObject.isSimple() || bObject.isStruct()) && Flags.isOperator(this, slotCursor.slot())) {
                    bl2 = true;
                } else if (bObject.isComponent() && ((BComponent)bObject).getPermissions(spyWriter.getContext()).hasOperatorRead()) {
                    bl2 = true;
                }
            } else if (bPermissions.hasAdminRead()) {
                bl2 = true;
            }
            if (!bl2) continue;
            if (bl) {
                spyWriter.trTitle("Properties", 2);
                bl = false;
            }
            String string = property.getName();
            this.spySlot(spyWriter, string, this.getFlags(property), bObject);
        }
    }

    void spyActions(SpyWriter spyWriter) {
        Action[] actionArray = this.getActionsArray();
        if (actionArray.length == 0) {
            return;
        }
        boolean bl = true;
        BComponent bComponent = (BComponent)this;
        BPermissions bPermissions = bComponent.getPermissions(spyWriter.getContext());
        int n = 0;
        while (n < actionArray.length) {
            if (bPermissions.hasAdminRead() || !bPermissions.hasAdminRead() && bPermissions.hasOperatorRead() && Flags.isOperator(this, actionArray[n])) {
                if (bl) {
                    spyWriter.trTitle("Actions", 2);
                    bl = false;
                }
                this.spySlot(spyWriter, actionArray[n].getName(), this.getFlags(actionArray[n]), actionArray[n]);
            }
            ++n;
        }
    }

    void spyTopics(SpyWriter spyWriter) {
        Topic[] topicArray = this.getTopicsArray();
        if (topicArray.length == 0) {
            return;
        }
        boolean bl = true;
        BComponent bComponent = (BComponent)this;
        BPermissions bPermissions = bComponent.getPermissions(spyWriter.getContext());
        int n = 0;
        while (n < topicArray.length) {
            if (bPermissions.hasAdminRead() || !bPermissions.hasAdminRead() && bPermissions.hasOperatorRead() && Flags.isOperator(this, topicArray[n])) {
                if (bl) {
                    spyWriter.trTitle("Topics", 2);
                    bl = false;
                }
                this.spySlot(spyWriter, topicArray[n].getName(), this.getFlags(topicArray[n]), topicArray[n]);
            }
            ++n;
        }
    }

    void spySlot(SpyWriter spyWriter, String string, int n, Object object) {
        Slot slot = this.getSlot(string);
        if (slot.isProperty()) {
            string = "<a href='" + spyWriter.href(SlotPath.escape(string)) + "'>" + string + "</a>";
        }
        spyWriter.w("<tr><td align='left' nowrap='true'><b>").w(string).w("</b>");
        if (n == 0) {
            spyWriter.w("{0}");
        } else {
            spyWriter.w(" {").w(Flags.encodeToString(n)).w("}");
        }
        spyWriter.w("</td><td align='left' nowrap='true'>").safe(object.toString()).w("</td></tr>\n");
    }

    void spyKnobs(SpyWriter spyWriter) {
        if (!this.isComponent()) {
            return;
        }
        Knob[] knobArray = this.asComponent().getKnobs();
        if (knobArray.length == 0) {
            return;
        }
        spyWriter.trTitle("Knobs", 2);
        int n = 0;
        while (n < knobArray.length) {
            spyWriter.prop((Object)knobArray[n].getSourceSlotName(), knobArray[n].getLink());
            ++n;
        }
    }

    void spySubscribers(SpyWriter spyWriter) {
        if (!this.isComponent()) {
            return;
        }
        Subscriber[] subscriberArray = this.asComponent().getSubscribers();
        if (subscriberArray.length == 0) {
            return;
        }
        spyWriter.trTitle("Subscribers", 2);
        int n = 0;
        while (n < subscriberArray.length) {
            spyWriter.w("<tr><td colspan='2'>").w(subscriberArray[n]).w("</td></tr>");
            ++n;
        }
    }

    void spySpaceNode(SpyWriter spyWriter) {
        if (!this.isComponent()) {
            return;
        }
        BComponent bComponent = (BComponent)this;
        spyWriter.trTitle("SpaceNode", 2);
        spyWriter.prop((Object)"isMounted", bComponent.isMounted());
        spyWriter.prop((Object)"handle", bComponent.getHandle());
        spyWriter.prop((Object)"slotPath", bComponent.getSlotPath());
        spyWriter.prop((Object)"host", bComponent.getHost());
        spyWriter.prop((Object)"session", bComponent.getSession());
        spyWriter.prop((Object)"space", bComponent.getSpace());
        spyWriter.prop((Object)"absoluteOrd", bComponent.getAbsoluteOrd());
        spyWriter.prop((Object)"ordInHost", bComponent.getOrdInHost());
        spyWriter.prop((Object)"ordInSession", bComponent.getOrdInSession());
        spyWriter.prop((Object)"ordInSpace", bComponent.getOrdInSpace());
        spyWriter.prop((Object)"handleOrd", bComponent.getHandleOrd());
        spyWriter.prop((Object)"slotPathOrd", bComponent.getSlotPathOrd());
        spyWriter.prop((Object)"navOrd", bComponent.getNavOrd());
    }

    void spyDebug(SpyWriter spyWriter) {
        spyWriter.trTitle("Debug", 2);
        spyWriter.prop((Object)"debugString", this.toDebugString());
        spyWriter.prop((Object)"type", this.getType());
        spyWriter.prop((Object)"parent", this.getParent());
        spyWriter.prop((Object)"propertyInParent", this.getPropertyInParent());
        if (this.isComponent()) {
            BComponent bComponent = (BComponent)this;
            spyWriter.prop((Object)"running", bComponent.isRunning());
            spyWriter.prop((Object)"subscribed", bComponent.isSubscribed());
            spyWriter.prop((Object)"permanentlySubscribed", bComponent.isPermanentlySubscribed());
            spyWriter.prop((Object)"knobCount", bComponent.getKnobCount());
            spyWriter.prop((Object)"permissions", bComponent.getPermissions(spyWriter.getContext()));
            spyWriter.prop((Object)"slotsLoaded", ((ComponentSlotMap)this.slotMap).isBrokerPropsLoaded());
            spyWriter.prop((Object)"categoryMask", bComponent.getCategoryMask());
            spyWriter.prop((Object)"appliedCategoryMask", bComponent.getAppliedCategoryMask());
            spyWriter.prop((Object)"deepOrCategoryMask", ((ComponentSlotMap)this.slotMap).getDeepOrCategoryMask());
        }
    }

    protected static Property newProperty(int n, BValue bValue, BFacets bFacets) {
        if (bValue == null) {
            throw new NullPointerException("Null defaultValue");
        }
        if (bFacets == null) {
            bFacets = BFacets.NULL;
        }
        return new NProperty(n, bValue, bFacets);
    }

    protected static Property newProperty(int n, boolean bl, BFacets bFacets) {
        return BComplex.newProperty(n, BBoolean.make(bl), bFacets);
    }

    protected static Property newProperty(int n, int n2, BFacets bFacets) {
        return BComplex.newProperty(n, BInteger.make(n2), bFacets);
    }

    protected static Property newProperty(int n, long l, BFacets bFacets) {
        return BComplex.newProperty(n, BLong.make(l), bFacets);
    }

    protected static Property newProperty(int n, float f, BFacets bFacets) {
        return BComplex.newProperty(n, BFloat.make(f), bFacets);
    }

    protected static Property newProperty(int n, double d, BFacets bFacets) {
        return BComplex.newProperty(n, BDouble.make(d), bFacets);
    }

    protected static Property newProperty(int n, String string, BFacets bFacets) {
        return BComplex.newProperty(n, BString.make(string), bFacets);
    }

    protected static Property newProperty(int n, BValue bValue) {
        return BComplex.newProperty(n, bValue, null);
    }

    protected static Property newProperty(int n, boolean bl) {
        return BComplex.newProperty(n, BBoolean.make(bl), null);
    }

    protected static Property newProperty(int n, int n2) {
        return BComplex.newProperty(n, BInteger.make(n2), null);
    }

    protected static Property newProperty(int n, long l) {
        return BComplex.newProperty(n, BLong.make(l), null);
    }

    protected static Property newProperty(int n, float f) {
        return BComplex.newProperty(n, BFloat.make(f), null);
    }

    protected static Property newProperty(int n, double d) {
        return BComplex.newProperty(n, BDouble.make(d), null);
    }

    protected static Property newProperty(int n, String string) {
        return BComplex.newProperty(n, BString.make(string), null);
    }

    public Object fw(int n, Object object, Object object2, Object object3, Object object4) {
        if (n == 1) {
            return this.slotMap;
        }
        return super.fw(n, object, object2, object3, object4);
    }

    final ComplexSlotMap getSlotMap() {
        return this.slotMap;
    }

    public Type getType() {
        return TYPE;
    }

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

    BComplex() {
        ComplexType complexType = (ComplexType)this.getType();
        if (complexType.getTypeClass() != this.getClass() && !this.getClass().getName().startsWith("auto.")) {
            throw new TypeIntrospectionException(this.getClass(), "Class does override the getType() method");
        }
        this.slotMap = complexType.newSlotMap();
        this.slotMap.init(complexType, this);
    }

    static {
        BComplex.copyHintsDefault.defaultOnClone = true;
        BComplex.copyHintsExact.defaultOnClone = false;
        Class clazz = class$javax$baja$sys$BComplex;
        if (clazz == null) {
            clazz = class$javax$baja$sys$BComplex = BComplex.class("[Ljavax.baja.sys.BComplex;", false);
        }
        TYPE = Sys.loadType(clazz);
    }
}