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

package org.bouncycastle.crypto.params;

import org.bouncycastle.util.Arrays;
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;
import java.security.SecureRandom;

public final class Ed25519PrivateKeyParameters extends AsymmetricKeyParameter
{
    public static final int KEY_SIZE = 32;
    public static final int SIGNATURE_SIZE = 64;
    private final byte[] data;
    private Ed25519PublicKeyParameters cachedPublicKey;
    
    public Ed25519PrivateKeyParameters(final SecureRandom secureRandom) {
        super(true);
        Ed25519.generatePrivateKey(secureRandom, this.data = new byte[32]);
    }
    
    public Ed25519PrivateKeyParameters(final byte[] array) {
        this(validate(array), 0);
    }
    
    public Ed25519PrivateKeyParameters(final byte[] array, final int n) {
        super(true);
        System.arraycopy(array, n, this.data = new byte[32], 0, 32);
    }
    
    public Ed25519PrivateKeyParameters(final InputStream inputStream) throws IOException {
        super(true);
        this.data = new byte[32];
        if (32 != Streams.readFully(inputStream, this.data)) {
            throw new EOFException("EOF encountered in middle of Ed25519 private key");
        }
    }
    
    public void encode(final byte[] array, final int n) {
        System.arraycopy(this.data, 0, array, n, 32);
    }
    
    public byte[] getEncoded() {
        return Arrays.clone(this.data);
    }
    
    public Ed25519PublicKeyParameters generatePublicKey() {
        synchronized (this.data) {
            if (null == this.cachedPublicKey) {
                this.cachedPublicKey = new Ed25519PublicKeyParameters(Ed25519.generatePublicKey(this.data, 0));
            }
            return this.cachedPublicKey;
        }
    }
    
    @Deprecated
    public void sign(final int n, final Ed25519PublicKeyParameters ed25519PublicKeyParameters, final byte[] array, final byte[] array2, final int n2, final int n3, final byte[] array3, final int n4) {
        this.sign(n, array, array2, n2, n3, array3, n4);
    }
    
    public void sign(final int n, final byte[] array, final byte[] array2, final int n2, final int n3, final byte[] array3, final int n4) {
        final Ed25519PublicKeyParameters generatePublicKey = this.generatePublicKey();
        final byte[] array4 = new byte[32];
        generatePublicKey.encode(array4, 0);
        switch (n) {
            case 0: {
                if (null != array) {
                    throw new IllegalArgumentException("ctx");
                }
                Ed25519.sign(this.data, 0, array4, 0, array2, n2, n3, array3, n4);
                break;
            }
            case 1: {
                if (null == array) {
                    throw new NullPointerException("'ctx' cannot be null");
                }
                if (array.length > 255) {
                    throw new IllegalArgumentException("ctx");
                }
                Ed25519.sign(this.data, 0, array4, 0, array, array2, n2, n3, array3, n4);
                break;
            }
            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");
                }
                Ed25519.signPrehash(this.data, 0, array4, 0, array, array2, n2, array3, n4);
                break;
            }
            default: {
                throw new IllegalArgumentException("algorithm");
            }
        }
    }
    
    private static byte[] validate(final byte[] array) {
        if (array.length != 32) {
            throw new IllegalArgumentException("'buf' must have length 32");
        }
        return array;
    }
}