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

package org.bouncycastle.asn1.eac;

import org.bouncycastle.asn1.ASN1OctetString;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.ASN1Encodable;
import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1Primitive;
import java.io.IOException;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.ASN1TaggedObject;
import org.bouncycastle.asn1.ASN1InputStream;
import org.bouncycastle.asn1.ASN1Object;

public class CertificateBody extends ASN1Object
{
    ASN1InputStream seq;
    private ASN1TaggedObject certificateProfileIdentifier;
    private ASN1TaggedObject certificationAuthorityReference;
    private PublicKeyDataObject publicKey;
    private ASN1TaggedObject certificateHolderReference;
    private CertificateHolderAuthorization certificateHolderAuthorization;
    private ASN1TaggedObject certificateEffectiveDate;
    private ASN1TaggedObject certificateExpirationDate;
    private int certificateType;
    private static final int CPI = 1;
    private static final int CAR = 2;
    private static final int PK = 4;
    private static final int CHR = 8;
    private static final int CHA = 16;
    private static final int CEfD = 32;
    private static final int CExD = 64;
    @Deprecated
    public static final int profileType = 127;
    private static final int profileType_m = 127;
    private static final int profileType_r = 0;
    @Deprecated
    public static final int requestType = 13;
    private static final int requestType_m = 13;
    private static final int requestType_r = 2;
    
    private void setIso7816CertificateBody(final ASN1TaggedObject asn1TaggedObject) throws IOException {
        if (asn1TaggedObject.hasTag(64, 78)) {
            final ASN1Sequence instance = ASN1Sequence.getInstance(asn1TaggedObject.getBaseUniversal(false, 16));
            for (int i = 0; i < instance.size(); ++i) {
                final ASN1TaggedObject instance2 = ASN1TaggedObject.getInstance(instance.getObjectAt(i), 64);
                switch (instance2.getTagNo()) {
                    case 41: {
                        this.setCertificateProfileIdentifier(instance2);
                        break;
                    }
                    case 2: {
                        this.setCertificationAuthorityReference(instance2);
                        break;
                    }
                    case 73: {
                        this.setPublicKey(PublicKeyDataObject.getInstance(instance2.getBaseUniversal(false, 16)));
                        break;
                    }
                    case 32: {
                        this.setCertificateHolderReference(instance2);
                        break;
                    }
                    case 76: {
                        this.setCertificateHolderAuthorization(new CertificateHolderAuthorization(instance2));
                        break;
                    }
                    case 37: {
                        this.setCertificateEffectiveDate(instance2);
                        break;
                    }
                    case 36: {
                        this.setCertificateExpirationDate(instance2);
                        break;
                    }
                    default: {
                        this.certificateType = 0;
                        throw new IOException("Not a valid iso7816 ASN1TaggedObject tag " + instance2.getTagNo());
                    }
                }
            }
            return;
        }
        throw new IOException("Bad tag : not an iso7816 CERTIFICATE_CONTENT_TEMPLATE");
    }
    
    public CertificateBody(final ASN1TaggedObject certificateProfileIdentifier, final CertificationAuthorityReference certificationAuthorityReference, final PublicKeyDataObject publicKey, final CertificateHolderReference certificateHolderReference, final CertificateHolderAuthorization certificateHolderAuthorization, final PackedDate packedDate, final PackedDate packedDate2) {
        this.certificateType = 0;
        this.setCertificateProfileIdentifier(certificateProfileIdentifier);
        this.setCertificationAuthorityReference(EACTagged.create(2, certificationAuthorityReference.getEncoded()));
        this.setPublicKey(publicKey);
        this.setCertificateHolderReference(EACTagged.create(32, certificateHolderReference.getEncoded()));
        this.setCertificateHolderAuthorization(certificateHolderAuthorization);
        this.setCertificateEffectiveDate(EACTagged.create(37, packedDate.getEncoding()));
        this.setCertificateExpirationDate(EACTagged.create(36, packedDate2.getEncoding()));
    }
    
    private CertificateBody(final ASN1TaggedObject iso7816CertificateBody) throws IOException {
        this.certificateType = 0;
        this.setIso7816CertificateBody(iso7816CertificateBody);
    }
    
    private ASN1Primitive profileToASN1Object() throws IOException {
        final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector(7);
        asn1EncodableVector.add(this.certificateProfileIdentifier);
        asn1EncodableVector.add(this.certificationAuthorityReference);
        asn1EncodableVector.add(EACTagged.create(73, this.publicKey));
        asn1EncodableVector.add(this.certificateHolderReference);
        asn1EncodableVector.add(this.certificateHolderAuthorization);
        asn1EncodableVector.add(this.certificateEffectiveDate);
        asn1EncodableVector.add(this.certificateExpirationDate);
        return EACTagged.create(78, new DERSequence(asn1EncodableVector));
    }
    
    private void setCertificateProfileIdentifier(final ASN1TaggedObject certificateProfileIdentifier) throws IllegalArgumentException {
        if (certificateProfileIdentifier.hasTag(64, 41)) {
            this.certificateProfileIdentifier = certificateProfileIdentifier;
            this.certificateType |= 0x1;
            return;
        }
        throw new IllegalArgumentException("Not an Iso7816Tags.INTERCHANGE_PROFILE tag :" + certificateProfileIdentifier.getTagNo());
    }
    
    private void setCertificateHolderReference(final ASN1TaggedObject certificateHolderReference) throws IllegalArgumentException {
        if (certificateHolderReference.hasTag(64, 32)) {
            this.certificateHolderReference = certificateHolderReference;
            this.certificateType |= 0x8;
            return;
        }
        throw new IllegalArgumentException("Not an Iso7816Tags.CARDHOLDER_NAME tag");
    }
    
    private void setCertificationAuthorityReference(final ASN1TaggedObject certificationAuthorityReference) throws IllegalArgumentException {
        if (certificationAuthorityReference.hasTag(64, 2)) {
            this.certificationAuthorityReference = certificationAuthorityReference;
            this.certificateType |= 0x2;
            return;
        }
        throw new IllegalArgumentException("Not an Iso7816Tags.ISSUER_IDENTIFICATION_NUMBER tag");
    }
    
    private void setPublicKey(final PublicKeyDataObject publicKeyDataObject) {
        this.publicKey = PublicKeyDataObject.getInstance(publicKeyDataObject);
        this.certificateType |= 0x4;
    }
    
    private ASN1Primitive requestToASN1Object() throws IOException {
        final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector(3);
        asn1EncodableVector.add(this.certificateProfileIdentifier);
        if (this.certificationAuthorityReference != null) {
            asn1EncodableVector.add(this.certificationAuthorityReference);
        }
        asn1EncodableVector.add(EACTagged.create(73, this.publicKey));
        asn1EncodableVector.add(this.certificateHolderReference);
        return EACTagged.create(78, new DERSequence(asn1EncodableVector));
    }
    
    @Override
    public ASN1Primitive toASN1Primitive() {
        try {
            if ((this.certificateType & -1) == 0x7F) {
                return this.profileToASN1Object();
            }
            if ((this.certificateType & 0xFFFFFFFD) == 0xD) {
                return this.requestToASN1Object();
            }
        }
        catch (final IOException ex) {}
        return null;
    }
    
    public int getCertificateType() {
        return this.certificateType;
    }
    
    public static CertificateBody getInstance(final Object o) throws IOException {
        if (o instanceof CertificateBody) {
            return (CertificateBody)o;
        }
        if (o != null) {
            return new CertificateBody(ASN1TaggedObject.getInstance(o, 64));
        }
        return null;
    }
    
    public PackedDate getCertificateEffectiveDate() {
        if ((this.certificateType & 0x20) == 0x20) {
            return new PackedDate(ASN1OctetString.getInstance(this.certificateEffectiveDate.getBaseUniversal(false, 4)).getOctets());
        }
        return null;
    }
    
    private void setCertificateEffectiveDate(final ASN1TaggedObject certificateEffectiveDate) throws IllegalArgumentException {
        if (certificateEffectiveDate.hasTag(64, 37)) {
            this.certificateEffectiveDate = certificateEffectiveDate;
            this.certificateType |= 0x20;
            return;
        }
        throw new IllegalArgumentException("Not an Iso7816Tags.APPLICATION_EFFECTIVE_DATE tag :" + certificateEffectiveDate.getTagNo());
    }
    
    public PackedDate getCertificateExpirationDate() throws IOException {
        if ((this.certificateType & 0x40) == 0x40) {
            return new PackedDate(ASN1OctetString.getInstance(this.certificateExpirationDate.getBaseUniversal(false, 4)).getOctets());
        }
        throw new IOException("certificate Expiration Date not set");
    }
    
    private void setCertificateExpirationDate(final ASN1TaggedObject certificateExpirationDate) throws IllegalArgumentException {
        if (certificateExpirationDate.hasTag(64, 36)) {
            this.certificateExpirationDate = certificateExpirationDate;
            this.certificateType |= 0x40;
            return;
        }
        throw new IllegalArgumentException("Not an Iso7816Tags.APPLICATION_EXPIRATION_DATE tag");
    }
    
    public CertificateHolderAuthorization getCertificateHolderAuthorization() throws IOException {
        if ((this.certificateType & 0x10) == 0x10) {
            return this.certificateHolderAuthorization;
        }
        throw new IOException("Certificate Holder Authorisation not set");
    }
    
    private void setCertificateHolderAuthorization(final CertificateHolderAuthorization certificateHolderAuthorization) {
        this.certificateHolderAuthorization = certificateHolderAuthorization;
        this.certificateType |= 0x10;
    }
    
    public CertificateHolderReference getCertificateHolderReference() {
        return new CertificateHolderReference(ASN1OctetString.getInstance(this.certificateHolderReference.getBaseUniversal(false, 4)).getOctets());
    }
    
    public ASN1TaggedObject getCertificateProfileIdentifier() {
        return this.certificateProfileIdentifier;
    }
    
    public CertificationAuthorityReference getCertificationAuthorityReference() throws IOException {
        if ((this.certificateType & 0x2) == 0x2) {
            return new CertificationAuthorityReference(ASN1OctetString.getInstance(this.certificationAuthorityReference.getBaseUniversal(false, 4)).getOctets());
        }
        throw new IOException("Certification authority reference not set");
    }
    
    public PublicKeyDataObject getPublicKey() {
        return this.publicKey;
    }
}