// 
// Decompiled by Procyon v0.6.0
// 

package org.bouncycastle.asn1;

import java.io.IOException;
import org.bouncycastle.util.Arrays;
import java.math.BigInteger;

public class ASN1Enumerated extends ASN1Primitive
{
    static final ASN1UniversalType TYPE;
    private final byte[] contents;
    private final int start;
    private static final ASN1Enumerated[] cache;
    
    public static ASN1Enumerated getInstance(final Object o) {
        if (o == null || o instanceof ASN1Enumerated) {
            return (ASN1Enumerated)o;
        }
        if (o instanceof byte[]) {
            try {
                return (ASN1Enumerated)ASN1Enumerated.TYPE.fromByteArray((byte[])o);
            }
            catch (final Exception ex) {
                throw new IllegalArgumentException("encoding error in getInstance: " + ex.toString());
            }
        }
        throw new IllegalArgumentException("illegal object in getInstance: " + o.getClass().getName());
    }
    
    public static ASN1Enumerated getInstance(final ASN1TaggedObject asn1TaggedObject, final boolean b) {
        return (ASN1Enumerated)ASN1Enumerated.TYPE.getContextTagged(asn1TaggedObject, b);
    }
    
    public static ASN1Enumerated getTagged(final ASN1TaggedObject asn1TaggedObject, final boolean b) {
        return (ASN1Enumerated)ASN1Enumerated.TYPE.getTagged(asn1TaggedObject, b);
    }
    
    public ASN1Enumerated(final int n) {
        if (n < 0) {
            throw new IllegalArgumentException("enumerated must be non-negative");
        }
        this.contents = BigInteger.valueOf(n).toByteArray();
        this.start = 0;
    }
    
    public ASN1Enumerated(final BigInteger bigInteger) {
        if (bigInteger.signum() < 0) {
            throw new IllegalArgumentException("enumerated must be non-negative");
        }
        this.contents = bigInteger.toByteArray();
        this.start = 0;
    }
    
    public ASN1Enumerated(final byte[] array) {
        this(array, true);
    }
    
    ASN1Enumerated(final byte[] array, final boolean b) {
        if (ASN1Integer.isMalformed(array)) {
            throw new IllegalArgumentException("malformed enumerated");
        }
        if (0x0 != (array[0] & 0x80)) {
            throw new IllegalArgumentException("enumerated must be non-negative");
        }
        this.contents = (b ? Arrays.clone(array) : array);
        this.start = ASN1Integer.signBytesToSkip(array);
    }
    
    public BigInteger getValue() {
        return new BigInteger(this.contents);
    }
    
    public boolean hasValue(final int n) {
        return this.contents.length - this.start <= 4 && ASN1Integer.intValue(this.contents, this.start, -1) == n;
    }
    
    public boolean hasValue(final BigInteger x) {
        return null != x && ASN1Integer.intValue(this.contents, this.start, -1) == x.intValue() && this.getValue().equals(x);
    }
    
    public int intValueExact() {
        if (this.contents.length - this.start > 4) {
            throw new ArithmeticException("ASN.1 Enumerated out of int range");
        }
        return ASN1Integer.intValue(this.contents, this.start, -1);
    }
    
    @Override
    boolean encodeConstructed() {
        return false;
    }
    
    @Override
    int encodedLength(final boolean b) {
        return ASN1OutputStream.getLengthOfEncodingDL(b, this.contents.length);
    }
    
    @Override
    void encode(final ASN1OutputStream asn1OutputStream, final boolean b) throws IOException {
        asn1OutputStream.writeEncodingDL(b, 10, this.contents);
    }
    
    @Override
    boolean asn1Equals(final ASN1Primitive asn1Primitive) {
        return asn1Primitive instanceof ASN1Enumerated && Arrays.areEqual(this.contents, ((ASN1Enumerated)asn1Primitive).contents);
    }
    
    @Override
    public int hashCode() {
        return Arrays.hashCode(this.contents);
    }
    
    static ASN1Enumerated createPrimitive(final byte[] array, final boolean b) {
        if (array.length > 1) {
            return new ASN1Enumerated(array, b);
        }
        if (array.length == 0) {
            throw new IllegalArgumentException("ENUMERATED has zero length");
        }
        final int n = array[0] & 0xFF;
        if (n >= ASN1Enumerated.cache.length) {
            return new ASN1Enumerated(array, b);
        }
        ASN1Enumerated asn1Enumerated = ASN1Enumerated.cache[n];
        if (asn1Enumerated == null) {
            final ASN1Enumerated[] cache = ASN1Enumerated.cache;
            final int n2 = n;
            final ASN1Enumerated asn1Enumerated2 = new ASN1Enumerated(array, b);
            cache[n2] = asn1Enumerated2;
            asn1Enumerated = asn1Enumerated2;
        }
        return asn1Enumerated;
    }
    
    static {
        TYPE = new ASN1UniversalType(10) {
            @Override
            ASN1Primitive fromImplicitPrimitive(final DEROctetString derOctetString) {
                return ASN1Enumerated.createPrimitive(derOctetString.getOctets(), false);
            }
        };
        cache = new ASN1Enumerated[12];
    }
}