/* package whatever; // don't place package name! */
 
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.zip.DataFormatException;
import java.util.zip.Deflater;
import java.util.zip.Inflater;
 
class ZlibMain {
 
    private static byte[] compress(final byte[] data) {
        final Deflater deflater = new Deflater();
        deflater.setInput(data);
 
        deflater.finish();
        final byte[] bytesCompressed = new byte[Short.MAX_VALUE];
        final int numberOfBytesAfterCompression = deflater.deflate(bytesCompressed);
        final byte[] returnValues = new byte[numberOfBytesAfterCompression];
        System.arraycopy(bytesCompressed, 0, returnValues, 0, numberOfBytesAfterCompression);
        return returnValues;
 
    }
 
    private static byte[] decompress(final byte[] data) {
        final Inflater inflater = new Inflater();
        inflater.setInput(data);
        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream(data.length)) {
            final byte[] buffer = new byte[Math.max(1024, data.length / 10)];
            while (!inflater.finished()) {
                final int count = inflater.inflate(buffer);
                outputStream.write(buffer, 0, count);
            }
            outputStream.close();
            final byte[] output = outputStream.toByteArray();
            return output;
        } catch (DataFormatException | IOException e) {
            throw new RuntimeException(e);
        }
    }
 
    public static void main(final String[] args) {
        roundTrip(100);
        roundTrip(1000);
        roundTrip(10000);
        roundTrip(20000);
        roundTrip(30000);
        roundTrip(32000);
        for (int i = 32700; i < 33000; i++) {
            if(!roundTrip(i))break;
        }
    }
 
    private static boolean roundTrip(final int i) {
        System.out.printf("Starting round trip with size %d: ", i);
        final byte[] data = new byte[i];
        for (int j = 0; j < data.length; j++) {
            data[j]= (byte) j;
        }
        shuffleArray(data);
 
        final byte[] compressed = compress(data);
        try {
            final byte[] decompressed = CompletableFuture.supplyAsync(() -> decompress(compressed))
                                                         .get(2, TimeUnit.SECONDS);
            System.out.printf("Success (%s)%n", Arrays.equals(data, decompressed) ? "matching" : "non-matching");
            return true;
        } catch (InterruptedException | ExecutionException | TimeoutException e) {
            System.out.println("Failure!");
            return false;
        }
    }
 
    // Implementing Fisher–Yates shuffle
    // source: https://stackoverflow.com/a/1520212/342852
    static void shuffleArray(byte[] ar)
    {
        // If running on Java 6 or older, use `new Random()` on RHS here
        Random rnd = ThreadLocalRandom.current();
        for (int i = ar.length - 1; i > 0; i--)
        {
            int index = rnd.nextInt(i + 1);
            // Simple swap
            byte a = ar[index];
            ar[index] = ar[i];
            ar[i] = a;
        }
    }
}

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