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

package org.bouncycastle.pqc.crypto.lms;

import java.io.IOException;
import org.bouncycastle.util.io.Streams;
import java.io.InputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import org.bouncycastle.util.Arrays;

public class LMSPublicKeyParameters extends LMSKeyParameters implements LMSContextBasedVerifier
{
    private final LMSigParameters parameterSet;
    private final LMOtsParameters lmOtsType;
    private final byte[] I;
    private final byte[] T1;
    
    public LMSPublicKeyParameters(final LMSigParameters parameterSet, final LMOtsParameters lmOtsType, final byte[] array, final byte[] array2) {
        super(false);
        this.parameterSet = parameterSet;
        this.lmOtsType = lmOtsType;
        this.I = Arrays.clone(array2);
        this.T1 = Arrays.clone(array);
    }
    
    public static LMSPublicKeyParameters getInstance(final Object obj) throws IOException {
        if (obj instanceof LMSPublicKeyParameters) {
            return (LMSPublicKeyParameters)obj;
        }
        if (obj instanceof DataInputStream) {
            final LMSigParameters parametersForType = LMSigParameters.getParametersForType(((DataInputStream)obj).readInt());
            final LMOtsParameters parametersForType2 = LMOtsParameters.getParametersForType(((DataInputStream)obj).readInt());
            final byte[] b = new byte[16];
            ((DataInputStream)obj).readFully(b);
            final byte[] b2 = new byte[parametersForType.getM()];
            ((DataInputStream)obj).readFully(b2);
            return new LMSPublicKeyParameters(parametersForType, parametersForType2, b2, b);
        }
        if (obj instanceof byte[]) {
            Object o = null;
            try {
                o = new DataInputStream(new ByteArrayInputStream((byte[])obj));
                return getInstance(o);
            }
            finally {
                if (o != null) {
                    ((InputStream)o).close();
                }
            }
        }
        if (obj instanceof InputStream) {
            return getInstance(Streams.readAll((InputStream)obj));
        }
        throw new IllegalArgumentException("cannot parse " + obj);
    }
    
    @Override
    public byte[] getEncoded() throws IOException {
        return this.toByteArray();
    }
    
    public LMSigParameters getSigParameters() {
        return this.parameterSet;
    }
    
    public LMOtsParameters getOtsParameters() {
        return this.lmOtsType;
    }
    
    public LMSParameters getLMSParameters() {
        return new LMSParameters(this.getSigParameters(), this.getOtsParameters());
    }
    
    public byte[] getT1() {
        return Arrays.clone(this.T1);
    }
    
    boolean matchesT1(final byte[] array) {
        return Arrays.constantTimeAreEqual(this.T1, array);
    }
    
    public byte[] getI() {
        return Arrays.clone(this.I);
    }
    
    byte[] refI() {
        return this.I;
    }
    
    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        final LMSPublicKeyParameters lmsPublicKeyParameters = (LMSPublicKeyParameters)o;
        return this.parameterSet.equals(lmsPublicKeyParameters.parameterSet) && this.lmOtsType.equals(lmsPublicKeyParameters.lmOtsType) && Arrays.areEqual(this.I, lmsPublicKeyParameters.I) && Arrays.areEqual(this.T1, lmsPublicKeyParameters.T1);
    }
    
    @Override
    public int hashCode() {
        return 31 * (31 * (31 * this.parameterSet.hashCode() + this.lmOtsType.hashCode()) + Arrays.hashCode(this.I)) + Arrays.hashCode(this.T1);
    }
    
    byte[] toByteArray() {
        return Composer.compose().u32str(this.parameterSet.getType()).u32str(this.lmOtsType.getType()).bytes(this.I).bytes(this.T1).build();
    }
    
    @Override
    public LMSContext generateLMSContext(final byte[] array) {
        try {
            return this.generateOtsContext(LMSSignature.getInstance(array));
        }
        catch (final IOException ex) {
            throw new IllegalStateException("cannot parse signature: " + ex.getMessage());
        }
    }
    
    LMSContext generateOtsContext(final LMSSignature lmsSignature) {
        final int type = this.getOtsParameters().getType();
        if (lmsSignature.getOtsSignature().getType().getType() != type) {
            throw new IllegalArgumentException("ots type from lsm signature does not match ots signature type from embedded ots signature");
        }
        return new LMOtsPublicKey(LMOtsParameters.getParametersForType(type), this.I, lmsSignature.getQ(), null).createOtsContext(lmsSignature);
    }
    
    @Override
    public boolean verify(final LMSContext lmsContext) {
        return LMS.verifySignature(this, lmsContext);
    }
}