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

package org.bouncycastle.asn1.cmp;

import org.bouncycastle.asn1.x509.GeneralName;
import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.DERTaggedObject;
import org.bouncycastle.asn1.ASN1Encodable;
import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1Primitive;
import org.bouncycastle.asn1.DEROctetString;
import org.bouncycastle.asn1.ASN1TaggedObject;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.cms.EnvelopedData;
import org.bouncycastle.asn1.ASN1OctetString;
import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
import org.bouncycastle.asn1.ASN1Object;

public class Challenge extends ASN1Object
{
    private final AlgorithmIdentifier owf;
    private final ASN1OctetString witness;
    private final ASN1OctetString challenge;
    private final EnvelopedData encryptedRand;
    
    private Challenge(final ASN1Sequence asn1Sequence) {
        int n = 0;
        if (asn1Sequence.getObjectAt(0).toASN1Primitive() instanceof ASN1Sequence) {
            this.owf = AlgorithmIdentifier.getInstance(asn1Sequence.getObjectAt(n++));
        }
        else {
            this.owf = null;
        }
        this.witness = ASN1OctetString.getInstance(asn1Sequence.getObjectAt(n++));
        this.challenge = ASN1OctetString.getInstance(asn1Sequence.getObjectAt(n++));
        if (asn1Sequence.size() > n) {
            if (this.challenge.getOctets().length != 0) {
                throw new IllegalArgumentException("ambigous challenge");
            }
            this.encryptedRand = EnvelopedData.getInstance(ASN1TaggedObject.getInstance(asn1Sequence.getObjectAt(n)), true);
        }
        else {
            this.encryptedRand = null;
        }
    }
    
    public Challenge(final byte[] array, final byte[] array2) {
        this(null, array, array2);
    }
    
    public Challenge(final byte[] array, final EnvelopedData envelopedData) {
        this(null, array, envelopedData);
    }
    
    public Challenge(final AlgorithmIdentifier owf, final byte[] array, final byte[] array2) {
        this.owf = owf;
        this.witness = new DEROctetString(array);
        this.challenge = new DEROctetString(array2);
        this.encryptedRand = null;
    }
    
    public Challenge(final AlgorithmIdentifier owf, final byte[] array, final EnvelopedData encryptedRand) {
        this.owf = owf;
        this.witness = new DEROctetString(array);
        this.challenge = new DEROctetString(new byte[0]);
        this.encryptedRand = encryptedRand;
    }
    
    public static Challenge getInstance(final Object o) {
        if (o instanceof Challenge) {
            return (Challenge)o;
        }
        if (o != null) {
            return new Challenge(ASN1Sequence.getInstance(o));
        }
        return null;
    }
    
    public AlgorithmIdentifier getOwf() {
        return this.owf;
    }
    
    public byte[] getWitness() {
        return this.witness.getOctets();
    }
    
    public boolean isEncryptedRand() {
        return this.encryptedRand != null;
    }
    
    public byte[] getChallenge() {
        return this.challenge.getOctets();
    }
    
    public EnvelopedData getEncryptedRand() {
        return this.encryptedRand;
    }
    
    @Override
    public ASN1Primitive toASN1Primitive() {
        final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector(3);
        asn1EncodableVector.addOptional(this.owf);
        asn1EncodableVector.add(this.witness);
        asn1EncodableVector.add(this.challenge);
        if (this.encryptedRand != null) {
            asn1EncodableVector.add(new DERTaggedObject(0, this.encryptedRand));
        }
        return new DERSequence(asn1EncodableVector);
    }
    
    public static class Rand extends ASN1Object
    {
        private final ASN1Integer integer;
        private final GeneralName sender;
        
        public Rand(final byte[] array, final GeneralName generalName) {
            this(new ASN1Integer(array), generalName);
        }
        
        public Rand(final ASN1Integer integer, final GeneralName sender) {
            this.integer = integer;
            this.sender = sender;
        }
        
        private Rand(final ASN1Sequence asn1Sequence) {
            if (asn1Sequence.size() != 2) {
                throw new IllegalArgumentException("expected sequence size of 2");
            }
            this.integer = ASN1Integer.getInstance(asn1Sequence.getObjectAt(0));
            this.sender = GeneralName.getInstance(asn1Sequence.getObjectAt(1));
        }
        
        public static Rand getInstance(final Object o) {
            if (o instanceof Rand) {
                return (Rand)o;
            }
            if (o != null) {
                return new Rand(ASN1Sequence.getInstance(o));
            }
            return null;
        }
        
        public ASN1Integer getInt() {
            return this.integer;
        }
        
        public GeneralName getSender() {
            return this.sender;
        }
        
        @Override
        public ASN1Primitive toASN1Primitive() {
            return new DERSequence(new ASN1Encodable[] { this.integer, this.sender });
        }
    }
}