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

package org.bouncycastle.asn1.x509;

import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.DERTaggedObject;
import org.bouncycastle.asn1.ASN1EncodableVector;
import java.util.Enumeration;
import org.bouncycastle.asn1.ASN1Primitive;
import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.bouncycastle.asn1.ASN1Encodable;
import org.bouncycastle.asn1.ASN1TaggedObject;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.ASN1BitString;
import org.bouncycastle.asn1.x500.X500Name;
import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.ASN1Object;

public class DeltaCertificateDescriptor extends ASN1Object
{
    private final ASN1Integer serialNumber;
    private final AlgorithmIdentifier signature;
    private final X500Name issuer;
    private final Validity validity;
    private final X500Name subject;
    private final SubjectPublicKeyInfo subjectPublicKeyInfo;
    private final Extensions extensions;
    private final ASN1BitString signatureValue;
    
    public static DeltaCertificateDescriptor getInstance(final Object o) {
        if (o instanceof DeltaCertificateDescriptor) {
            return (DeltaCertificateDescriptor)o;
        }
        if (o != null) {
            return new DeltaCertificateDescriptor(ASN1Sequence.getInstance(o));
        }
        return null;
    }
    
    public static DeltaCertificateDescriptor fromExtensions(final Extensions extensions) {
        return getInstance(Extensions.getExtensionParsedValue(extensions, Extension.deltaCertificateDescriptor));
    }
    
    private DeltaCertificateDescriptor(final ASN1Sequence asn1Sequence) {
        final ASN1Integer instance = ASN1Integer.getInstance(asn1Sequence.getObjectAt(0));
        int n = 1;
        ASN1Encodable asn1Encodable = asn1Sequence.getObjectAt(n++);
        AlgorithmIdentifier instance2 = null;
        X500Name instance3 = null;
        Validity instance4 = null;
        X500Name instance5 = null;
        while (asn1Encodable instanceof ASN1TaggedObject) {
            final ASN1TaggedObject instance6 = ASN1TaggedObject.getInstance(asn1Encodable);
            switch (instance6.getTagNo()) {
                case 0: {
                    instance2 = AlgorithmIdentifier.getInstance(instance6, true);
                    break;
                }
                case 1: {
                    instance3 = X500Name.getInstance(instance6, true);
                    break;
                }
                case 2: {
                    instance4 = Validity.getInstance(instance6, true);
                    break;
                }
                case 3: {
                    instance5 = X500Name.getInstance(instance6, true);
                    break;
                }
            }
            asn1Encodable = asn1Sequence.getObjectAt(n++);
        }
        final SubjectPublicKeyInfo instance7 = SubjectPublicKeyInfo.getInstance(asn1Encodable);
        ASN1Encodable asn1Encodable2 = asn1Sequence.getObjectAt(n);
        Extensions instance8 = null;
        while (asn1Encodable2 instanceof ASN1TaggedObject) {
            final ASN1TaggedObject instance9 = ASN1TaggedObject.getInstance(asn1Encodable2);
            switch (instance9.getTagNo()) {
                case 4: {
                    instance8 = Extensions.getInstance(instance9, true);
                    break;
                }
            }
            asn1Encodable2 = asn1Sequence.getObjectAt(n++);
        }
        final ASN1BitString instance10 = ASN1BitString.getInstance(asn1Encodable2);
        this.serialNumber = instance;
        this.signature = instance2;
        this.issuer = instance3;
        this.validity = instance4;
        this.subject = instance5;
        this.subjectPublicKeyInfo = instance7;
        this.extensions = instance8;
        this.signatureValue = instance10;
    }
    
    public DeltaCertificateDescriptor(final ASN1Integer serialNumber, final AlgorithmIdentifier signature, final X500Name issuer, final Validity validity, final X500Name subject, final SubjectPublicKeyInfo subjectPublicKeyInfo, final Extensions extensions, final ASN1BitString signatureValue) {
        if (serialNumber == null) {
            throw new NullPointerException("'serialNumber' cannot be null");
        }
        if (subjectPublicKeyInfo == null) {
            throw new NullPointerException("'subjectPublicKeyInfo' cannot be null");
        }
        if (signatureValue == null) {
            throw new NullPointerException("'signatureValue' cannot be null");
        }
        this.serialNumber = serialNumber;
        this.signature = signature;
        this.issuer = issuer;
        this.validity = validity;
        this.subject = subject;
        this.subjectPublicKeyInfo = subjectPublicKeyInfo;
        this.extensions = extensions;
        this.signatureValue = signatureValue;
    }
    
    public ASN1Integer getSerialNumber() {
        return this.serialNumber;
    }
    
    public AlgorithmIdentifier getSignature() {
        return this.signature;
    }
    
    public X500Name getIssuer() {
        return this.issuer;
    }
    
    @Deprecated
    public ASN1Sequence getValidity() {
        return (ASN1Sequence)this.validity.toASN1Primitive();
    }
    
    public Validity getValidityObject() {
        return this.validity;
    }
    
    public X500Name getSubject() {
        return this.subject;
    }
    
    public SubjectPublicKeyInfo getSubjectPublicKeyInfo() {
        return this.subjectPublicKeyInfo;
    }
    
    public Extensions getExtensions() {
        return this.extensions;
    }
    
    public ASN1BitString getSignatureValue() {
        return this.signatureValue;
    }
    
    @Deprecated
    public DeltaCertificateDescriptor trimTo(final TBSCertificate tbsCertificate, final Extensions extensions) {
        return trimDeltaCertificateDescriptor(this, tbsCertificate, extensions);
    }
    
    private static DeltaCertificateDescriptor trimDeltaCertificateDescriptor(final DeltaCertificateDescriptor deltaCertificateDescriptor, final TBSCertificate tbsCertificate, final Extensions extensions) {
        final ASN1Integer serialNumber = deltaCertificateDescriptor.getSerialNumber();
        AlgorithmIdentifier signature = deltaCertificateDescriptor.getSignature();
        if (signature != null && signature.equals(tbsCertificate.getSignature())) {
            signature = null;
        }
        X500Name issuer = deltaCertificateDescriptor.getIssuer();
        if (issuer != null && issuer.equals(tbsCertificate.getIssuer())) {
            issuer = null;
        }
        Validity validityObject = deltaCertificateDescriptor.getValidityObject();
        if (validityObject != null && validityObject.equals(tbsCertificate.getValidity())) {
            validityObject = null;
        }
        X500Name subject = deltaCertificateDescriptor.getSubject();
        if (subject != null && subject.equals(tbsCertificate.getSubject())) {
            subject = null;
        }
        final SubjectPublicKeyInfo subjectPublicKeyInfo = deltaCertificateDescriptor.getSubjectPublicKeyInfo();
        Extensions extensions2 = deltaCertificateDescriptor.getExtensions();
        if (extensions2 != null) {
            final ExtensionsGenerator extensionsGenerator = new ExtensionsGenerator();
            final Enumeration oids = extensions.oids();
            while (oids.hasMoreElements()) {
                final ASN1ObjectIdentifier asn1ObjectIdentifier = oids.nextElement();
                if (Extension.deltaCertificateDescriptor.equals(asn1ObjectIdentifier)) {
                    continue;
                }
                final Extension extension = extensions2.getExtension(asn1ObjectIdentifier);
                if (extension == null || extension.equals(extensions.getExtension(asn1ObjectIdentifier))) {
                    continue;
                }
                extensionsGenerator.addExtension(extension);
            }
            extensions2 = (extensionsGenerator.isEmpty() ? null : extensionsGenerator.generate());
        }
        return new DeltaCertificateDescriptor(serialNumber, signature, issuer, validityObject, subject, subjectPublicKeyInfo, extensions2, deltaCertificateDescriptor.getSignatureValue());
    }
    
    private void addOptional(final ASN1EncodableVector asn1EncodableVector, final int n, final boolean b, final ASN1Object asn1Object) {
        if (asn1Object != null) {
            asn1EncodableVector.add(new DERTaggedObject(b, n, asn1Object));
        }
    }
    
    @Override
    public ASN1Primitive toASN1Primitive() {
        final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector(8);
        asn1EncodableVector.add(this.serialNumber);
        this.addOptional(asn1EncodableVector, 0, true, this.signature);
        this.addOptional(asn1EncodableVector, 1, true, this.issuer);
        this.addOptional(asn1EncodableVector, 2, true, this.validity);
        this.addOptional(asn1EncodableVector, 3, true, this.subject);
        asn1EncodableVector.add(this.subjectPublicKeyInfo);
        this.addOptional(asn1EncodableVector, 4, true, this.extensions);
        asn1EncodableVector.add(this.signatureValue);
        return new DERSequence(asn1EncodableVector);
    }
}