// 
// 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;

public class HSSPublicKeyParameters extends LMSKeyParameters implements LMSContextBasedVerifier
{
    private final int l;
    private final LMSPublicKeyParameters lmsPublicKey;
    
    public HSSPublicKeyParameters(final int l, final LMSPublicKeyParameters lmsPublicKey) {
        super(false);
        if (lmsPublicKey == null) {
            throw new NullPointerException("lmsPublicKey");
        }
        this.l = l;
        this.lmsPublicKey = lmsPublicKey;
    }
    
    public static HSSPublicKeyParameters getInstance(final Object obj) throws IOException {
        if (obj instanceof HSSPublicKeyParameters) {
            return (HSSPublicKeyParameters)obj;
        }
        if (obj instanceof DataInputStream) {
            return new HSSPublicKeyParameters(((DataInputStream)obj).readInt(), LMSPublicKeyParameters.getInstance(obj));
        }
        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);
    }
    
    public int getL() {
        return this.l;
    }
    
    public LMSPublicKeyParameters getLMSPublicKey() {
        return this.lmsPublicKey;
    }
    
    @Override
    public boolean equals(final Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        final HSSPublicKeyParameters hssPublicKeyParameters = (HSSPublicKeyParameters)o;
        return this.l == hssPublicKeyParameters.l && this.lmsPublicKey.equals(hssPublicKeyParameters.lmsPublicKey);
    }
    
    @Override
    public int hashCode() {
        return 31 * this.l + this.lmsPublicKey.hashCode();
    }
    
    @Override
    public byte[] getEncoded() throws IOException {
        return Composer.compose().u32str(this.l).bytes(this.lmsPublicKey.getEncoded()).build();
    }
    
    @Override
    public LMSContext generateLMSContext(final byte[] array) {
        HSSSignature instance;
        try {
            instance = HSSSignature.getInstance(array, this.getL());
        }
        catch (final IOException ex) {
            throw new IllegalStateException("cannot parse signature: " + ex.getMessage());
        }
        final LMSSignedPubKey[] signedPubKey = instance.getSignedPubKey();
        LMSPublicKeyParameters lmsPublicKeyParameters;
        if (signedPubKey.length != 0) {
            lmsPublicKeyParameters = signedPubKey[signedPubKey.length - 1].getPublicKey();
        }
        else {
            lmsPublicKeyParameters = this.getLMSPublicKey();
        }
        return lmsPublicKeyParameters.generateOtsContext(instance.getSignature()).withSignedPublicKeys(signedPubKey);
    }
    
    @Override
    public boolean verify(final LMSContext lmsContext) {
        boolean b = true;
        final LMSSignedPubKey[] signedPubKeys = lmsContext.getSignedPubKeys();
        if (signedPubKeys.length != this.getL() - 1) {
            return false;
        }
        LMSPublicKeyParameters lmsPublicKeyParameters = this.getLMSPublicKey();
        for (int i = 0; i < signedPubKeys.length; ++i) {
            b &= LMS.verifySignature(lmsPublicKeyParameters, signedPubKeys[i].getSignature(), signedPubKeys[i].getPublicKey().toByteArray());
            lmsPublicKeyParameters = signedPubKeys[i].getPublicKey();
        }
        return b & lmsPublicKeyParameters.verify(lmsContext);
    }
}