/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  javax.baja.xml.XWriter
 */
package javax.baja.io;

import com.tridium.sys.schema.ComponentSlotMap;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.util.HashMap;
import javax.baja.category.BCategoryMask;
import javax.baja.io.BIContextEncodable;
import javax.baja.log.Log;
import javax.baja.naming.SlotPath;
import javax.baja.registry.TypeInfo;
import javax.baja.security.BPermissions;
import javax.baja.status.BStatus;
import javax.baja.status.BStatusBoolean;
import javax.baja.status.BStatusEnum;
import javax.baja.status.BStatusNumeric;
import javax.baja.status.BStatusString;
import javax.baja.status.BStatusValue;
import javax.baja.sys.BBoolean;
import javax.baja.sys.BComplex;
import javax.baja.sys.BComponent;
import javax.baja.sys.BDouble;
import javax.baja.sys.BFacets;
import javax.baja.sys.BFloat;
import javax.baja.sys.BInteger;
import javax.baja.sys.BLink;
import javax.baja.sys.BLong;
import javax.baja.sys.BModule;
import javax.baja.sys.BObject;
import javax.baja.sys.BSimple;
import javax.baja.sys.BString;
import javax.baja.sys.BValue;
import javax.baja.sys.BasicContext;
import javax.baja.sys.Context;
import javax.baja.sys.Flags;
import javax.baja.sys.Property;
import javax.baja.sys.Slot;
import javax.baja.sys.SlotCursor;
import javax.baja.sys.Sys;
import javax.baja.sys.Type;
import javax.baja.user.BUser;
import javax.baja.virtual.BVirtualComponentSpace;
import javax.baja.xml.XWriter;

/*
 * Illegal identifiers - consider using --renameillegalidents true
 */
public class ValueDocEncoder {
    private static final int SECURITY_INACCESSIBLE = 1;
    private static final int SECURITY_READONLY = 2;
    private static final Log log = Log.getLog("sys.xml");
    private static TypeInfo nullProxyExt = null;
    private boolean encodeTransients;
    private boolean encodeComments;
    private Context context;
    private HashMap permissionsCache;
    protected final IEncoderPlugin plugin;

    public static final String marshal(BValue bValue) throws IOException {
        return BogEncoderPlugin.marshal(bValue);
    }

    public Context getContext() {
        return this.context;
    }

    public static final Context getMergedContext(BComplex bComplex, Slot slot, Context context) {
        BFacets bFacets = bComplex.getSlotFacets(slot);
        if (context == null) {
            context = bFacets;
        } else if (bFacets != null && !bFacets.isNull()) {
            context = new BasicContext(context, bFacets);
        }
        if (bComplex.isStruct() && bComplex.getParent() != null) {
            return ValueDocEncoder.getMergedContext(bComplex.getParent(), bComplex.getPropertyInParent(), context);
        }
        return context;
    }

    public boolean isSyncEncoder() {
        return false;
    }

    public boolean isEncodeTransients() {
        return this.encodeTransients;
    }

    public boolean setEncodeTransients(boolean bl) {
        boolean bl2 = this.encodeTransients;
        this.encodeTransients = bl;
        return bl2;
    }

    public boolean isEncodeComments() {
        return this.encodeComments;
    }

    public boolean setEncodeComments(boolean bl) {
        boolean bl2 = this.encodeComments;
        this.encodeComments = bl;
        return bl2;
    }

    public final IEncoderPlugin getPlugin() {
        return this.plugin;
    }

    public void encodeDocument(BValue bValue) throws IOException {
        this.plugin.encodeDocument(this, bValue);
        this.plugin.flush();
    }

    public void encode(BValue bValue) throws IOException {
        this.encode(null, bValue, Integer.MAX_VALUE);
    }

    public void encode(String string, BValue bValue, int n) throws IOException {
        Object object;
        Object object2;
        BPermissions bPermissions = BPermissions.all;
        if (this.context != null && this.context != Context.encrypt && bValue.isComponent() && !(bPermissions = this.getPermissionsFor(bValue.asComponent())).hasOperatorRead()) {
            throw new SecurityException("Missing op read permission on value");
        }
        this.plugin.start("p");
        if (string != null) {
            this.wname(string);
        }
        if (bValue.isComponent()) {
            BCategoryMask bCategoryMask;
            object2 = (BComponent)bValue;
            object = ((BComponent)object2).getHandle();
            if (object != null) {
                this.whandle(object);
            }
            if (!(bCategoryMask = ((BComponent)object2).getCategoryMask()).isNull()) {
                this.wcategories(bCategoryMask);
            }
            if (((BComponent)object2).getComponentSpace() instanceof BVirtualComponentSpace && !((ComponentSlotMap)((BObject)object2).fw(1)).isBrokerPropsLoaded()) {
                this.plugin.attr("stub", true);
            }
        }
        this.wtype(bValue);
        object2 = this.getContext();
        if (bValue.isComplex() && bValue.asComplex().getParent() != null) {
            object = bValue.asComplex();
            object2 = ValueDocEncoder.getMergedContext(((BComplex)object).getParent(), ((BComplex)object).getPropertyInParent(), this.getContext());
        }
        this.encodeValue(bValue, n, bPermissions, (Context)object2);
    }

    public final void flush() throws IOException {
        this.plugin.flush();
    }

    public final void close() throws IOException {
        this.plugin.close();
    }

    public final IEncoderPlugin start(String string) throws IOException {
        return this.plugin.start(string);
    }

    public final IEncoderPlugin startArray(String string) throws IOException {
        return this.plugin.startArray(string);
    }

    public final IEncoderPlugin endArray() throws IOException {
        return this.plugin.endArray();
    }

    public final IEncoderPlugin end() throws IOException {
        return this.plugin.end();
    }

    public final IEncoderPlugin end(String string) throws IOException {
        return this.plugin.end(string);
    }

    public final IEncoderPlugin endAttr() throws IOException {
        return this.plugin.endAttr();
    }

    public final IEncoderPlugin key(String string) throws IOException {
        return this.plugin.key(string);
    }

    public final IEncoderPlugin attr(String string, boolean bl) throws IOException {
        return this.plugin.attr(string, bl);
    }

    public final IEncoderPlugin attr(String string, double d) throws IOException {
        return this.plugin.attr(string, d);
    }

    public final IEncoderPlugin attr(String string, String string2) throws IOException {
        return this.plugin.attr(string, string2);
    }

    public final IEncoderPlugin attrSafe(String string, String string2) throws IOException {
        return this.plugin.attrSafe(string, string2);
    }

    public final IEncoderPlugin comment(String string) throws IOException {
        return this.plugin.comment(string);
    }

    public final IEncoderPlugin incrementIndent() throws IOException {
        return this.plugin.incrementIndent();
    }

    public final IEncoderPlugin decrementIndent() throws IOException {
        return this.plugin.decrementIndent();
    }

    public final IEncoderPlugin indent() throws IOException {
        return this.plugin.indent();
    }

    public final int getIndent() {
        return this.plugin.getIndent();
    }

    public final IEncoderPlugin newLine() throws IOException {
        return this.plugin.newLine();
    }

    public boolean isZipped() {
        return this.plugin.isZipped();
    }

    public void setZipped(boolean bl) throws IOException {
        this.plugin.setZipped(bl);
    }

    protected void encodingComponent(BComponent bComponent) throws IOException {
    }

    protected void encodingComponentStub(BComponent bComponent) throws IOException {
    }

    protected void encodingValue(BValue bValue, Context context) throws IOException {
    }

    protected void encodingSlot(BComplex bComplex, Slot slot) throws IOException {
    }

    protected void encodingFacets(BFacets bFacets) throws IOException {
    }

    private final void encodeSlot(BComplex bComplex, Slot slot, int n, BPermissions bPermissions) throws IOException {
        Object object;
        int n2;
        if (slot == null) {
            return;
        }
        int n3 = bComplex.getFlags(slot);
        boolean bl = false;
        if (!this.encodeTransients && (n3 & 2) != 0) {
            if (slot.isProperty() && slot.isFrozen() && n3 != slot.getDefaultFlags()) {
                bl = true;
            } else {
                return;
            }
        }
        Property property = null;
        BObject bObject = null;
        boolean bl2 = false;
        if (slot.isProperty() && !bl) {
            property = (Property)slot;
            if (this.encodePrimitive(bComplex, property, n3)) {
                return;
            }
            bObject = bComplex.get(property);
            bl2 = this.canSkipEncodingProperty(bComplex, property, (BValue)bObject, bPermissions);
        } else {
            bl2 = true;
        }
        if (this.context != null && this.context != Context.encrypt) {
            n2 = this.getSecurityMask(bPermissions, slot, (BValue)bObject, n3);
            if ((n2 & 1) != 0) {
                if (slot.isFrozen()) {
                    n3 |= 4;
                } else {
                    return;
                }
            }
            if ((n2 & 2) != 0) {
                n3 |= 1;
            }
        }
        if (bObject != null && bObject.isSimple() && this.isTypeBlackListed(((BValue)bObject).getType())) {
            if (slot.isFrozen()) {
                n3 |= 4;
            } else {
                return;
            }
        }
        if (n3 == slot.getDefaultFlags() && bl2) {
            return;
        }
        int n4 = 0;
        if (slot.isDynamic() && bObject instanceof BComponent) {
            n4 = 1;
        }
        n2 = n4;
        this.plugin.indent();
        if (n2 != 0 && this.encodeComments && (object = ((BComponent)bObject).getSlotPath()) != null) {
            this.plugin.comment(((SlotPath)object).getBody());
            this.plugin.indent();
        }
        if (slot.isProperty()) {
            this.plugin.start("p");
        } else if (slot.isAction()) {
            this.plugin.start("a");
        } else if (slot.isTopic()) {
            this.plugin.start("t");
        } else {
            throw new IllegalStateException();
        }
        this.wname(slot.getName());
        this.encodingSlot(bComplex, slot);
        if ((slot.isDynamic() && n3 != 0 || n3 != slot.getDefaultFlags()) && bComplex.isComponent()) {
            this.wflags(n3);
        }
        object = slot.getFacets();
        if (slot.isDynamic() && !((BFacets)object).isNull()) {
            this.wfacets((BFacets)object);
        }
        if (bObject instanceof BComponent) {
            BCategoryMask bCategoryMask;
            BComponent bComponent = (BComponent)bObject;
            Object object2 = bComponent.getHandle();
            if (object2 != null) {
                this.whandle(object2);
            }
            if (!(bCategoryMask = bComponent.getCategoryMask()).isNull()) {
                this.wcategories(bCategoryMask);
            }
            if (n == 0 || bComponent.getComponentSpace() instanceof BVirtualComponentSpace && !((ComponentSlotMap)bComponent.fw(1)).isBrokerPropsLoaded()) {
                this.plugin.attr("stub", true);
            }
        }
        if (property != null && !bl2) {
            this.wtype(bObject);
            this.encodeValue((BValue)bObject, n - 1, bPermissions, ValueDocEncoder.getMergedContext(bComplex, property, this.getContext()));
        } else {
            this.plugin.end().newLine();
        }
    }

    private final boolean encodePrimitive(BComplex bComplex, Property property, int n) throws IOException {
        if (property.isDynamic() || n != property.getDefaultFlags()) {
            return false;
        }
        if (property.getTypeAccess() == 7) {
            return false;
        }
        if (this.isSyncEncoder()) {
            return false;
        }
        String string = null;
        boolean bl = false;
        switch (property.getTypeAccess()) {
            case 0: {
                boolean bl2 = bComplex.getBoolean(property);
                if (bl2 == ((BBoolean)property.getDefaultValue()).getBoolean()) {
                    return true;
                }
                string = BBoolean.encode(bl2);
                break;
            }
            case 2: {
                int n2 = bComplex.getInt(property);
                if (n2 == ((BInteger)property.getDefaultValue()).getInt()) {
                    return true;
                }
                string = BInteger.encode(n2);
                break;
            }
            case 3: {
                long l = bComplex.getLong(property);
                if (l == ((BLong)property.getDefaultValue()).getLong()) {
                    return true;
                }
                string = BLong.encode(l);
                break;
            }
            case 4: {
                float f = bComplex.getFloat(property);
                if (f == ((BFloat)property.getDefaultValue()).getFloat()) {
                    return true;
                }
                string = BFloat.encode(f);
                break;
            }
            case 5: {
                double d = bComplex.getDouble(property);
                if (d == ((BDouble)property.getDefaultValue()).getDouble()) {
                    return true;
                }
                string = BDouble.encode(d);
                break;
            }
            case 6: {
                string = bComplex.getString(property);
                bl = true;
                if (string != ((BString)property.getDefaultValue()).getString()) break;
                return true;
            }
            default: {
                throw new IllegalStateException("" + property.getTypeAccess());
            }
        }
        this.plugin.indent().start("p");
        this.wname(property.getName());
        if (bl) {
            this.plugin.attrSafe("v", string);
        } else {
            this.plugin.attr("v", string);
        }
        this.encodingValue(bComplex.get(property), ValueDocEncoder.getMergedContext(bComplex, property, this.getContext()));
        this.plugin.end().newLine();
        return true;
    }

    private final void encodeValue(BValue bValue, int n, BPermissions bPermissions, Context context) throws IOException {
        this.encodingValue(bValue, context);
        if (this.isTypeBlackListed(bValue.getType()) && bValue.isSimple()) {
            bValue = (BValue)bValue.getType().getInstance();
        }
        if (bValue.isSimple()) {
            this.wvalue((BSimple)bValue);
            this.plugin.end().newLine();
        } else if (bValue.isComponent() && n < 0) {
            this.plugin.endAttr();
            this.encodingComponentStub((BComponent)bValue);
            this.plugin.end("p").newLine();
        } else {
            if (bValue.isComponent()) {
                bPermissions = this.getPermissionsFor(bValue.asComponent());
            }
            if (this.encodeStructValue(bValue)) {
                return;
            }
            this.plugin.endAttr().newLine().incrementIndent();
            BComplex bComplex = (BComplex)bValue;
            SlotCursor slotCursor = bComplex.getSlots();
            boolean bl = true;
            while (slotCursor.next()) {
                if (bl) {
                    this.plugin.startArray("s");
                    bl = false;
                }
                this.encodeSlot(bComplex, slotCursor.slot(), n, bPermissions);
            }
            if (!bl) {
                this.plugin.endArray();
            }
            if (bComplex.isComponent()) {
                this.encodingComponent(bComplex.asComponent());
            }
            this.plugin.decrementIndent().indent().end("p").newLine();
        }
    }

    protected boolean canSkipEncodingProperty(BComplex bComplex, Property property, BValue bValue, BPermissions bPermissions) {
        if (!property.isFrozen()) {
            return false;
        }
        if (bValue.isComponent()) {
            boolean bl = false;
            if (!this.isSyncEncoder() && bValue.getType().getTypeInfo() == nullProxyExt) {
                bl = true;
            }
            return bl;
        }
        return property.isEquivalentToDefaultValue(bValue);
    }

    private final boolean encodeStructValue(BValue bValue) throws IOException {
        if (bValue instanceof BStatusValue) {
            return this.encodeStatusValue(bValue);
        }
        if (bValue instanceof BLink) {
            return this.encodeLink(bValue);
        }
        return false;
    }

    private final boolean encodeLink(BValue bValue) throws IOException {
        if (bValue.getType() != BLink.TYPE) {
            return false;
        }
        BLink bLink = (BLink)bValue;
        this.plugin.endAttr().startArray("s");
        this.plugin.start("p").attr("n", "sourceOrd").attrSafe("v", bLink.getSourceOrd().encodeToString());
        this.encodingSlot(bLink, BLink.sourceOrd);
        this.encodingValue(bLink.getSourceOrd(), ValueDocEncoder.getMergedContext(bLink, BLink.sourceOrd, this.getContext()));
        this.plugin.end();
        this.plugin.start("p").attr("n", "sourceSlotName").attrSafe("v", bLink.getSourceSlotName());
        this.encodingSlot(bLink, BLink.sourceSlotName);
        this.encodingValue(bLink.get(BLink.sourceSlotName), ValueDocEncoder.getMergedContext(bLink, BLink.sourceSlotName, this.getContext()));
        this.plugin.end();
        this.plugin.start("p").attr("n", "targetSlotName").attrSafe("v", bLink.getTargetSlotName());
        this.encodingSlot(bLink, BLink.targetSlotName);
        this.encodingValue(bLink.get(BLink.targetSlotName), ValueDocEncoder.getMergedContext(bLink, BLink.targetSlotName, this.getContext()));
        this.plugin.end();
        if (!bLink.getEnabled()) {
            this.plugin.start("p").attr("n", "enabled").attr("v", false);
            this.encodingSlot(bLink, BLink.enabled);
            this.encodingValue(bLink.get(BLink.enabled), ValueDocEncoder.getMergedContext(bLink, BLink.enabled, this.getContext()));
            this.plugin.end();
        }
        this.plugin.endArray().end("p").newLine();
        return true;
    }

    private final boolean encodeStatusValue(BValue bValue) throws IOException {
        BStatus bStatus = null;
        if (bValue.getType() == BStatusNumeric.TYPE) {
            BStatusNumeric bStatusNumeric = (BStatusNumeric)bValue;
            this.plugin.endAttr().startArray("s").start("p").attr("n", "value").attr("v", BDouble.encode(bStatusNumeric.getValue()));
            this.encodingSlot(bStatusNumeric, BStatusNumeric.value);
            this.encodingValue(bStatusNumeric.get(BStatusNumeric.value), ValueDocEncoder.getMergedContext(bStatusNumeric, BStatusNumeric.value, this.getContext()));
            this.plugin.end();
            bStatus = bStatusNumeric.getStatus();
        } else if (bValue.getType() == BStatusBoolean.TYPE) {
            BStatusBoolean bStatusBoolean = (BStatusBoolean)bValue;
            this.plugin.endAttr().startArray("s").start("p").attr("n", "value").attr("v", BBoolean.encode(bStatusBoolean.getValue()));
            this.encodingSlot(bStatusBoolean, BStatusBoolean.value);
            this.encodingValue(bStatusBoolean.get(BStatusBoolean.value), ValueDocEncoder.getMergedContext(bStatusBoolean, BStatusBoolean.value, this.getContext()));
            this.plugin.end();
            bStatus = bStatusBoolean.getStatus();
        } else if (bValue.getType() == BStatusEnum.TYPE) {
            BStatusEnum bStatusEnum = (BStatusEnum)bValue;
            this.plugin.endAttr().startArray("s").start("p").attr("n", "value").attr("v", bStatusEnum.getValue().encodeToString());
            this.encodingSlot(bStatusEnum, BStatusEnum.value);
            this.encodingValue(bStatusEnum.get(BStatusEnum.value), ValueDocEncoder.getMergedContext(bStatusEnum, BStatusEnum.value, this.getContext()));
            this.plugin.end();
            bStatus = bStatusEnum.getStatus();
        } else if (bValue.getType() == BStatusString.TYPE) {
            BStatusString bStatusString = (BStatusString)bValue;
            this.plugin.endAttr().startArray("s").start("p").attr("n", "value").attrSafe("v", bStatusString.getValue());
            this.encodingSlot(bStatusString, BStatusString.value);
            this.encodingValue(bStatusString.get(BStatusString.value), ValueDocEncoder.getMergedContext(bStatusString, BStatusString.value, this.getContext()));
            this.plugin.end();
            bStatus = bStatusString.getStatus();
        } else {
            return false;
        }
        if (!bStatus.equals(BStatus.DEFAULT)) {
            this.plugin.start("p").attr("n", "status").attrSafe("v", bStatus.encodeToString());
            this.encodingSlot(bValue.asComplex(), BStatusValue.status);
            this.encodingValue(bStatus, ValueDocEncoder.getMergedContext(bValue.asComplex(), BStatusValue.status, this.getContext()));
            this.plugin.end();
        }
        this.plugin.endArray().end("p").newLine();
        return true;
    }

    public BPermissions getPermissionsFor(BComponent bComponent) {
        BPermissions bPermissions;
        if (this.context == null) {
            return BPermissions.all;
        }
        BUser bUser = this.context.getUser();
        if (bUser == null) {
            return BPermissions.all;
        }
        if (this.permissionsCache == null) {
            this.permissionsCache = new HashMap();
        }
        if ((bPermissions = (BPermissions)this.permissionsCache.get(bComponent)) == null) {
            bPermissions = bComponent.getPermissions(this.context);
            this.permissionsCache.put(bComponent, bPermissions);
        }
        return bPermissions;
    }

    private final int getSecurityMask(BPermissions bPermissions, Slot slot, BValue bValue, int n) {
        boolean bl = false;
        boolean bl2 = false;
        if (slot.isProperty() && bValue.isComponent()) {
            if (!this.getPermissionsFor(bValue.asComponent()).has(BPermissions.operatorRead)) {
                bl = true;
            }
        } else if (slot.isAction()) {
            if ((n & 0x100) != 0) {
                if (!bPermissions.has(BPermissions.operatorInvoke)) {
                    bl = true;
                }
            } else if (!bPermissions.has(BPermissions.adminInvoke)) {
                bl = true;
            }
        } else if ((n & 0x100) != 0) {
            if (!bPermissions.has(BPermissions.operatorRead)) {
                bl = true;
            } else if (!bPermissions.has(BPermissions.operatorWrite)) {
                bl2 = true;
            }
        } else if (!bPermissions.has(BPermissions.adminRead)) {
            bl = true;
        } else if (!bPermissions.has(BPermissions.adminWrite)) {
            bl2 = true;
        }
        int n2 = 0;
        if (bl) {
            n2 |= 1;
        }
        if (bl2) {
            n2 |= 2;
        }
        return n2;
    }

    private final ValueDocEncoder wname(String string) throws IOException {
        this.plugin.attr("n", string);
        return this;
    }

    private final ValueDocEncoder wtype(BObject bObject) throws IOException {
        this.plugin.encodeType(bObject.getType());
        return this;
    }

    private final ValueDocEncoder wtype(Type type) throws IOException {
        this.plugin.encodeType(type);
        return this;
    }

    private final ValueDocEncoder wflags(int n) throws IOException {
        this.plugin.attr("f", Flags.encodeToString(n));
        return this;
    }

    private final ValueDocEncoder whandle(Object object) throws IOException {
        this.plugin.attr("h", object.toString());
        return this;
    }

    private final ValueDocEncoder wcategories(BCategoryMask bCategoryMask) throws IOException {
        this.plugin.attr("c", bCategoryMask.encodeToString());
        return this;
    }

    private final ValueDocEncoder wfacets(BFacets bFacets) throws IOException {
        this.encodingFacets(bFacets);
        this.plugin.attrSafe("x", bFacets.encodeToString());
        return this;
    }

    private final ValueDocEncoder wvalue(BSimple bSimple) throws IOException {
        try {
            String string = this.encodeSimple(bSimple);
            this.plugin.attrSafe("v", string);
        }
        catch (Exception exception) {
            String string = "?";
            try {
                string = bSimple.toString();
            }
            catch (Exception exception2) {}
            log.error("Encoding " + bSimple.getType() + " \"" + string + '\"', exception);
            this.plugin.attr("err", bSimple.getType() + ".encodeToString()");
        }
        return this;
    }

    protected String encodeSimple(BSimple bSimple) throws IOException {
        if (bSimple instanceof BIContextEncodable) {
            return ((BIContextEncodable)((Object)bSimple)).encodeToString(this.context);
        }
        return bSimple.encodeToString();
    }

    public boolean isTypeBlackListed(Type type) {
        return false;
    }

    private final /* synthetic */ void this() {
        this.encodeComments = true;
    }

    public ValueDocEncoder(IEncoderPlugin iEncoderPlugin) throws IOException {
        this.this();
        this.plugin = iEncoderPlugin;
    }

    public ValueDocEncoder(IEncoderPlugin iEncoderPlugin, Context context) throws IOException {
        this.this();
        this.plugin = iEncoderPlugin;
        this.context = context;
    }

    public ValueDocEncoder(File file) throws IOException {
        this(new BogEncoderPlugin(file));
    }

    public ValueDocEncoder(OutputStream outputStream) throws IOException {
        this(new BogEncoderPlugin(outputStream));
    }

    public ValueDocEncoder(File file, Context context) throws IOException {
        this(new BogEncoderPlugin(file), context);
    }

    public ValueDocEncoder(OutputStream outputStream, Context context) throws IOException {
        this(new BogEncoderPlugin(outputStream), context);
    }

    static {
        try {
            nullProxyExt = Sys.getRegistry().getType("control:NullProxyExt");
        }
        catch (Exception exception) {}
    }

    /*
     * Illegal identifiers - consider using --renameillegalidents true
     */
    public static final class BogEncoderPlugin
    implements IEncoderPlugin {
        protected int indent;
        private XWriter w;
        private HashMap modules;
        private HashMap keys;

        public final IEncoderPlugin encodeDocument(ValueDocEncoder valueDocEncoder, BValue bValue) throws IOException {
            this.w.w((Object)"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
            this.w.w((Object)"<bajaObjectGraph version=\"1.0\">\n");
            valueDocEncoder.encode(bValue);
            this.w.w((Object)"</bajaObjectGraph>\n");
            return this;
        }

        public final IEncoderPlugin start(String string) throws IOException {
            this.w.w((Object)"<").w((Object)string);
            return this;
        }

        public final IEncoderPlugin startArray(String string) throws IOException {
            return this;
        }

        public final IEncoderPlugin endArray() throws IOException {
            return this;
        }

        public final IEncoderPlugin end() throws IOException {
            this.w.w((Object)"/>");
            return this;
        }

        public final IEncoderPlugin end(String string) throws IOException {
            this.w.w((Object)"</").w((Object)string).w((Object)">");
            return this;
        }

        public final IEncoderPlugin endAttr() throws IOException {
            this.w.w((Object)">");
            return this;
        }

        public final IEncoderPlugin newLine() throws IOException {
            this.w.w((Object)"\n");
            return this;
        }

        public final IEncoderPlugin key(String string) throws IOException {
            return this;
        }

        public final IEncoderPlugin attr(String string, boolean bl) throws IOException {
            this.attr(string, String.valueOf(bl));
            return this;
        }

        public final IEncoderPlugin attr(String string, double d) throws IOException {
            this.attr(string, String.valueOf(d));
            return this;
        }

        public final IEncoderPlugin attr(String string, String string2) throws IOException {
            this.w.w((Object)" ").w((Object)string).w((Object)"=\"").w((Object)string2).w((Object)"\"");
            return this;
        }

        public final IEncoderPlugin attrSafe(String string, String string2) throws IOException {
            this.w.w((Object)" ").w((Object)string).w((Object)"=\"").safe(string2).w((Object)"\"");
            return this;
        }

        public final IEncoderPlugin value(String string) throws IOException {
            return this;
        }

        public final IEncoderPlugin comment(String string) throws IOException {
            this.w.w((Object)"<!-- ").w((Object)string).w((Object)" -->\n");
            return this;
        }

        public final IEncoderPlugin incrementIndent() throws IOException {
            ++this.indent;
            return this;
        }

        public final IEncoderPlugin decrementIndent() throws IOException {
            --this.indent;
            return this;
        }

        public final IEncoderPlugin indent() throws IOException {
            this.w.indent(this.indent);
            return this;
        }

        public final int getIndent() {
            return this.indent;
        }

        public final IEncoderPlugin encodeType(Type type) throws IOException {
            BModule bModule = type.getModule();
            String string = (String)this.modules.get(bModule.getModuleName());
            if (string == null) {
                string = this.newModuleKey(bModule);
                this.attr("m", string + '=' + bModule.getModuleName());
            }
            this.attr("t", string + ':' + type.getTypeName());
            return this;
        }

        public final void flush() throws IOException {
            this.w.flush();
        }

        public final void close() throws IOException {
            this.w.close();
        }

        public final boolean isZipped() {
            return this.w.isZipped();
        }

        public final void setZipped(boolean bl) throws IOException {
            this.w.setZipped(bl);
        }

        private final String newModuleKey(BModule bModule) {
            String string = bModule.getPreferredSymbol();
            int n = 0;
            while (this.keys.get(string) != null) {
                string = "" + string.charAt(0) + n;
                ++n;
            }
            this.keys.put(string, string);
            this.modules.put(bModule.getModuleName(), string);
            return string;
        }

        public static final String marshal(BValue bValue) throws IOException {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ValueDocEncoder valueDocEncoder = new ValueDocEncoder(new BogEncoderPlugin(byteArrayOutputStream));
            valueDocEncoder.encode(bValue);
            valueDocEncoder.close();
            return new String(byteArrayOutputStream.toByteArray());
        }

        public final XWriter getWriter() {
            return this.w;
        }

        private final /* synthetic */ void this() {
            this.indent = 0;
            this.modules = new HashMap(33);
            this.keys = new HashMap(33);
        }

        public BogEncoderPlugin(File file) throws IOException {
            this.this();
            this.w = new XWriter(file);
        }

        public BogEncoderPlugin(OutputStream outputStream) throws IOException {
            this.this();
            this.w = new XWriter(outputStream);
        }
    }

    public static interface IEncoderPlugin {
        public IEncoderPlugin encodeDocument(ValueDocEncoder var1, BValue var2) throws IOException;

        public IEncoderPlugin start(String var1) throws IOException;

        public IEncoderPlugin startArray(String var1) throws IOException;

        public IEncoderPlugin endArray() throws IOException;

        public IEncoderPlugin end() throws IOException;

        public IEncoderPlugin end(String var1) throws IOException;

        public IEncoderPlugin endAttr() throws IOException;

        public IEncoderPlugin key(String var1) throws IOException;

        public IEncoderPlugin attr(String var1, boolean var2) throws IOException;

        public IEncoderPlugin attr(String var1, double var2) throws IOException;

        public IEncoderPlugin attr(String var1, String var2) throws IOException;

        public IEncoderPlugin attrSafe(String var1, String var2) throws IOException;

        public IEncoderPlugin value(String var1) throws IOException;

        public IEncoderPlugin comment(String var1) throws IOException;

        public IEncoderPlugin incrementIndent() throws IOException;

        public IEncoderPlugin decrementIndent() throws IOException;

        public IEncoderPlugin indent() throws IOException;

        public int getIndent();

        public IEncoderPlugin newLine() throws IOException;

        public IEncoderPlugin encodeType(Type var1) throws IOException;

        public void flush() throws IOException;

        public void close() throws IOException;

        public boolean isZipped();

        public void setZipped(boolean var1) throws IOException;
    }
}