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

package org.bouncycastle.asn1;

import java.io.IOException;
import org.bouncycastle.util.Arrays;
import org.bouncycastle.util.Strings;

public abstract class ASN1PrintableString extends ASN1Primitive implements ASN1String
{
    static final ASN1UniversalType TYPE;
    final byte[] contents;
    
    public static ASN1PrintableString getInstance(final Object o) {
        if (o == null || o instanceof ASN1PrintableString) {
            return (ASN1PrintableString)o;
        }
        if (o instanceof ASN1Encodable) {
            final ASN1Primitive asn1Primitive = ((ASN1Encodable)o).toASN1Primitive();
            if (asn1Primitive instanceof ASN1PrintableString) {
                return (ASN1PrintableString)asn1Primitive;
            }
        }
        if (o instanceof byte[]) {
            try {
                return (ASN1PrintableString)ASN1PrintableString.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 ASN1PrintableString getInstance(final ASN1TaggedObject asn1TaggedObject, final boolean b) {
        return (ASN1PrintableString)ASN1PrintableString.TYPE.getContextTagged(asn1TaggedObject, b);
    }
    
    public static ASN1PrintableString getTagged(final ASN1TaggedObject asn1TaggedObject, final boolean b) {
        return (ASN1PrintableString)ASN1PrintableString.TYPE.getTagged(asn1TaggedObject, b);
    }
    
    ASN1PrintableString(final String s, final boolean b) {
        if (b && !isPrintableString(s)) {
            throw new IllegalArgumentException("string contains illegal characters");
        }
        this.contents = Strings.toByteArray(s);
    }
    
    ASN1PrintableString(final byte[] array, final boolean b) {
        this.contents = (b ? Arrays.clone(array) : array);
    }
    
    @Override
    public final String getString() {
        return Strings.fromByteArray(this.contents);
    }
    
    public final byte[] getOctets() {
        return Arrays.clone(this.contents);
    }
    
    @Override
    final boolean encodeConstructed() {
        return false;
    }
    
    @Override
    final int encodedLength(final boolean b) {
        return ASN1OutputStream.getLengthOfEncodingDL(b, this.contents.length);
    }
    
    @Override
    final void encode(final ASN1OutputStream asn1OutputStream, final boolean b) throws IOException {
        asn1OutputStream.writeEncodingDL(b, 19, this.contents);
    }
    
    @Override
    final boolean asn1Equals(final ASN1Primitive asn1Primitive) {
        return asn1Primitive instanceof ASN1PrintableString && Arrays.areEqual(this.contents, ((ASN1PrintableString)asn1Primitive).contents);
    }
    
    @Override
    public final int hashCode() {
        return Arrays.hashCode(this.contents);
    }
    
    @Override
    public String toString() {
        return this.getString();
    }
    
    public static boolean isPrintableString(final String s) {
        for (int i = s.length() - 1; i >= 0; --i) {
            final char char1 = s.charAt(i);
            if (char1 > '\u007f') {
                return false;
            }
            if ('a' > char1 || char1 > 'z') {
                if ('A' > char1 || char1 > 'Z') {
                    if ('0' > char1 || char1 > '9') {
                        switch (char1) {
                            case 32:
                            case 39:
                            case 40:
                            case 41:
                            case 43:
                            case 44:
                            case 45:
                            case 46:
                            case 47:
                            case 58:
                            case 61:
                            case 63: {
                                break;
                            }
                            default: {
                                return false;
                            }
                        }
                    }
                }
            }
        }
        return true;
    }
    
    static ASN1PrintableString createPrimitive(final byte[] array) {
        return new DERPrintableString(array, false);
    }
    
    static {
        TYPE = new ASN1UniversalType(19) {
            @Override
            ASN1Primitive fromImplicitPrimitive(final DEROctetString derOctetString) {
                return ASN1PrintableString.createPrimitive(derOctetString.getOctets());
            }
        };
    }
}