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

package org.bouncycastle.jcajce.provider.drbg;

import org.bouncycastle.crypto.prng.EntropySource;
import java.security.SecureRandom;
import org.bouncycastle.crypto.prng.EntropySourceProvider;

class IncrementalEntropySourceProvider implements EntropySourceProvider
{
    private final SecureRandom random;
    private final boolean predictionResistant;
    
    public IncrementalEntropySourceProvider(final SecureRandom random, final boolean predictionResistant) {
        this.random = random;
        this.predictionResistant = predictionResistant;
    }
    
    @Override
    public EntropySource get(final int n) {
        return new IncrementalEntropySource() {
            final int numBytes = (n + 7) / 8;
            
            @Override
            public boolean isPredictionResistant() {
                return IncrementalEntropySourceProvider.this.predictionResistant;
            }
            
            @Override
            public byte[] getEntropy() {
                try {
                    return this.getEntropy(0L);
                }
                catch (final InterruptedException ex) {
                    Thread.currentThread().interrupt();
                    throw new IllegalStateException("initial entropy fetch interrupted");
                }
            }
            
            @Override
            public byte[] getEntropy(final long n) throws InterruptedException {
                final byte[] array = new byte[this.numBytes];
                for (int i = 0; i < this.numBytes / 8; ++i) {
                    sleep(n);
                    final byte[] generateSeed = IncrementalEntropySourceProvider.this.random.generateSeed(8);
                    System.arraycopy(generateSeed, 0, array, i * 8, generateSeed.length);
                }
                final int numBytes = this.numBytes - this.numBytes / 8 * 8;
                if (numBytes != 0) {
                    sleep(n);
                    final byte[] generateSeed2 = IncrementalEntropySourceProvider.this.random.generateSeed(numBytes);
                    System.arraycopy(generateSeed2, 0, array, array.length - generateSeed2.length, generateSeed2.length);
                }
                return array;
            }
            
            @Override
            public int entropySize() {
                return n;
            }
        };
    }
    
    private static void sleep(final long millis) throws InterruptedException {
        if (millis != 0L) {
            Thread.sleep(millis);
        }
    }
}