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

package org.bouncycastle.crypto.params;

import java.io.IOException;
import java.io.EOFException;
import org.bouncycastle.util.io.Streams;
import java.io.InputStream;
import org.bouncycastle.math.ec.rfc8032.Ed25519;

public final class Ed25519PublicKeyParameters extends AsymmetricKeyParameter
{
    public static final int KEY_SIZE = 32;
    private final Ed25519.PublicPoint publicPoint;
    
    public Ed25519PublicKeyParameters(final byte[] array) {
        this(validate(array), 0);
    }
    
    public Ed25519PublicKeyParameters(final byte[] array, final int n) {
        super(false);
        this.publicPoint = parse(array, n);
    }
    
    public Ed25519PublicKeyParameters(final InputStream inputStream) throws IOException {
        super(false);
        final byte[] array = new byte[32];
        if (32 != Streams.readFully(inputStream, array)) {
            throw new EOFException("EOF encountered in middle of Ed25519 public key");
        }
        this.publicPoint = parse(array, 0);
    }
    
    public Ed25519PublicKeyParameters(final Ed25519.PublicPoint publicPoint) {
        super(false);
        if (publicPoint == null) {
            throw new NullPointerException("'publicPoint' cannot be null");
        }
        this.publicPoint = publicPoint;
    }
    
    public void encode(final byte[] array, final int n) {
        Ed25519.encodePublicPoint(this.publicPoint, array, n);
    }
    
    public byte[] getEncoded() {
        final byte[] array = new byte[32];
        this.encode(array, 0);
        return array;
    }
    
    public boolean verify(final int n, final byte[] array, final byte[] array2, final int n2, final int n3, final byte[] array3, final int n4) {
        switch (n) {
            case 0: {
                if (null != array) {
                    throw new IllegalArgumentException("ctx");
                }
                return Ed25519.verify(array3, n4, this.publicPoint, array2, n2, n3);
            }
            case 1: {
                if (null == array) {
                    throw new NullPointerException("'ctx' cannot be null");
                }
                if (array.length > 255) {
                    throw new IllegalArgumentException("ctx");
                }
                return Ed25519.verify(array3, n4, this.publicPoint, array, array2, n2, n3);
            }
            case 2: {
                if (null == array) {
                    throw new NullPointerException("'ctx' cannot be null");
                }
                if (array.length > 255) {
                    throw new IllegalArgumentException("ctx");
                }
                if (64 != n3) {
                    throw new IllegalArgumentException("msgLen");
                }
                return Ed25519.verifyPrehash(array3, n4, this.publicPoint, array, array2, n2);
            }
            default: {
                throw new IllegalArgumentException("algorithm");
            }
        }
    }
    
    private static Ed25519.PublicPoint parse(final byte[] array, final int n) {
        final Ed25519.PublicPoint validatePublicKeyPartialExport = Ed25519.validatePublicKeyPartialExport(array, n);
        if (validatePublicKeyPartialExport == null) {
            throw new IllegalArgumentException("invalid public key");
        }
        return validatePublicKeyPartialExport;
    }
    
    private static byte[] validate(final byte[] array) {
        if (array.length != 32) {
            throw new IllegalArgumentException("'buf' must have length 32");
        }
        return array;
    }
}