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

package org.bouncycastle.asn1.tsp;

import org.bouncycastle.asn1.DERTaggedObject;
import org.bouncycastle.asn1.ASN1Primitive;
import java.util.Enumeration;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.ASN1Encodable;
import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1TaggedObject;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.bouncycastle.asn1.ASN1Object;

public class EvidenceRecord extends ASN1Object
{
    private static final ASN1ObjectIdentifier OID;
    private ASN1Integer version;
    private ASN1Sequence digestAlgorithms;
    private CryptoInfos cryptoInfos;
    private EncryptionInfo encryptionInfo;
    private ArchiveTimeStampSequence archiveTimeStampSequence;
    
    public static EvidenceRecord getInstance(final Object o) {
        if (o instanceof EvidenceRecord) {
            return (EvidenceRecord)o;
        }
        if (o != null) {
            return new EvidenceRecord(ASN1Sequence.getInstance(o));
        }
        return null;
    }
    
    public static EvidenceRecord getInstance(final ASN1TaggedObject asn1TaggedObject, final boolean b) {
        return getInstance(ASN1Sequence.getInstance(asn1TaggedObject, b));
    }
    
    private EvidenceRecord(final EvidenceRecord evidenceRecord, final ArchiveTimeStampSequence archiveTimeStampSequence, final ArchiveTimeStamp archiveTimeStamp) {
        this.version = new ASN1Integer(1L);
        this.version = evidenceRecord.version;
        if (archiveTimeStamp != null) {
            final AlgorithmIdentifier digestAlgorithmIdentifier = archiveTimeStamp.getDigestAlgorithmIdentifier();
            final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector();
            final Enumeration objects = evidenceRecord.digestAlgorithms.getObjects();
            boolean b = false;
            while (objects.hasMoreElements()) {
                final AlgorithmIdentifier instance = AlgorithmIdentifier.getInstance(objects.nextElement());
                asn1EncodableVector.add(instance);
                if (instance.equals(digestAlgorithmIdentifier)) {
                    b = true;
                    break;
                }
            }
            if (!b) {
                asn1EncodableVector.add(digestAlgorithmIdentifier);
                this.digestAlgorithms = new DERSequence(asn1EncodableVector);
            }
            else {
                this.digestAlgorithms = evidenceRecord.digestAlgorithms;
            }
        }
        else {
            this.digestAlgorithms = evidenceRecord.digestAlgorithms;
        }
        this.cryptoInfos = evidenceRecord.cryptoInfos;
        this.encryptionInfo = evidenceRecord.encryptionInfo;
        this.archiveTimeStampSequence = archiveTimeStampSequence;
    }
    
    public EvidenceRecord(final CryptoInfos cryptoInfos, final EncryptionInfo encryptionInfo, final ArchiveTimeStamp archiveTimeStamp) {
        this.version = new ASN1Integer(1L);
        this.digestAlgorithms = new DERSequence(archiveTimeStamp.getDigestAlgorithmIdentifier());
        this.cryptoInfos = cryptoInfos;
        this.encryptionInfo = encryptionInfo;
        this.archiveTimeStampSequence = new ArchiveTimeStampSequence(new ArchiveTimeStampChain(archiveTimeStamp));
    }
    
    public EvidenceRecord(final AlgorithmIdentifier[] array, final CryptoInfos cryptoInfos, final EncryptionInfo encryptionInfo, final ArchiveTimeStampSequence archiveTimeStampSequence) {
        this.version = new ASN1Integer(1L);
        this.digestAlgorithms = new DERSequence(array);
        this.cryptoInfos = cryptoInfos;
        this.encryptionInfo = encryptionInfo;
        this.archiveTimeStampSequence = archiveTimeStampSequence;
    }
    
    private EvidenceRecord(final ASN1Sequence asn1Sequence) {
        this.version = new ASN1Integer(1L);
        if (asn1Sequence.size() < 3 && asn1Sequence.size() > 5) {
            throw new IllegalArgumentException("wrong sequence size in constructor: " + asn1Sequence.size());
        }
        final ASN1Integer instance = ASN1Integer.getInstance(asn1Sequence.getObjectAt(0));
        if (!instance.hasValue(1)) {
            throw new IllegalArgumentException("incompatible version");
        }
        this.version = instance;
        this.digestAlgorithms = ASN1Sequence.getInstance(asn1Sequence.getObjectAt(1));
        for (int i = 2; i != asn1Sequence.size() - 1; ++i) {
            final ASN1Encodable object = asn1Sequence.getObjectAt(i);
            if (!(object instanceof ASN1TaggedObject)) {
                throw new IllegalArgumentException("unknown object in getInstance: " + ((ASN1TaggedObject)object).getClass().getName());
            }
            final ASN1TaggedObject asn1TaggedObject = (ASN1TaggedObject)object;
            switch (asn1TaggedObject.getTagNo()) {
                case 0: {
                    this.cryptoInfos = CryptoInfos.getInstance(asn1TaggedObject, false);
                    break;
                }
                case 1: {
                    this.encryptionInfo = EncryptionInfo.getInstance(asn1TaggedObject, false);
                    break;
                }
                default: {
                    throw new IllegalArgumentException("unknown tag in getInstance: " + asn1TaggedObject.getTagNo());
                }
            }
        }
        this.archiveTimeStampSequence = ArchiveTimeStampSequence.getInstance(asn1Sequence.getObjectAt(asn1Sequence.size() - 1));
    }
    
    public AlgorithmIdentifier[] getDigestAlgorithms() {
        final AlgorithmIdentifier[] array = new AlgorithmIdentifier[this.digestAlgorithms.size()];
        for (int i = 0; i != array.length; ++i) {
            array[i] = AlgorithmIdentifier.getInstance(this.digestAlgorithms.getObjectAt(i));
        }
        return array;
    }
    
    public ArchiveTimeStampSequence getArchiveTimeStampSequence() {
        return this.archiveTimeStampSequence;
    }
    
    public EvidenceRecord addArchiveTimeStamp(final ArchiveTimeStamp archiveTimeStamp, final boolean b) {
        if (b) {
            return new EvidenceRecord(this, this.archiveTimeStampSequence.append(new ArchiveTimeStampChain(archiveTimeStamp)), archiveTimeStamp);
        }
        final ArchiveTimeStampChain[] archiveTimeStampChains = this.archiveTimeStampSequence.getArchiveTimeStampChains();
        if (!archiveTimeStampChains[archiveTimeStampChains.length - 1].getArchiveTimestamps()[0].getDigestAlgorithmIdentifier().equals(archiveTimeStamp.getDigestAlgorithmIdentifier())) {
            throw new IllegalArgumentException("mismatch of digest algorithm in addArchiveTimeStamp");
        }
        archiveTimeStampChains[archiveTimeStampChains.length - 1] = archiveTimeStampChains[archiveTimeStampChains.length - 1].append(archiveTimeStamp);
        return new EvidenceRecord(this, new ArchiveTimeStampSequence(archiveTimeStampChains), null);
    }
    
    @Override
    public String toString() {
        return "EvidenceRecord: Oid(" + EvidenceRecord.OID + ")";
    }
    
    @Override
    public ASN1Primitive toASN1Primitive() {
        final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector(5);
        asn1EncodableVector.add(this.version);
        asn1EncodableVector.add(this.digestAlgorithms);
        if (null != this.cryptoInfos) {
            asn1EncodableVector.add(new DERTaggedObject(false, 0, this.cryptoInfos));
        }
        if (null != this.encryptionInfo) {
            asn1EncodableVector.add(new DERTaggedObject(false, 1, this.encryptionInfo));
        }
        asn1EncodableVector.add(this.archiveTimeStampSequence);
        return new DERSequence(asn1EncodableVector);
    }
    
    static {
        OID = new ASN1ObjectIdentifier("1.3.6.1.5.5.11.0.2.1");
    }
}