/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.rng.simple;

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;
import java.util.function.LongSupplier;
import java.util.stream.Collectors;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.ArbitrarilyJumpableUniformRandomProvider;
import org.apache.commons.rng.JumpableUniformRandomProvider;
import org.apache.commons.rng.LongJumpableUniformRandomProvider;
import org.apache.commons.rng.RandomProviderState;
import org.apache.commons.rng.RestorableUniformRandomProvider;
import org.apache.commons.rng.SplittableUniformRandomProvider;
import org.apache.commons.rng.core.RandomProviderDefaultState;
import org.apache.commons.rng.core.source64.LongProvider;
import org.apache.commons.rng.core.source64.SplitMix64;

/**
 * Tests which all generators must pass.
 */
class ProvidersCommonParametricTest {
    private static Iterable<ProvidersList.Data> getProvidersTestData() {
        return ProvidersList.list();
    }

    // Seeding tests.

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testUnsupportedSeedType(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final byte seed = 123;
        final Object[] originalArgs = data.getArgs();
        Assertions.assertThrows(UnsupportedOperationException.class,
            () -> originalSource.create(seed, originalArgs));
    }

    /**
     * Test the factory create method returns the same class as the instance create method.
     */
    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testFactoryCreateMethod(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object originalSeed = data.getSeed();
        final Object[] originalArgs = data.getArgs();
        // Cannot test providers that require arguments
        Assumptions.assumeTrue(originalArgs == null);
        @SuppressWarnings("deprecation")
        final UniformRandomProvider rng = RandomSource.create(data.getSource());
        final UniformRandomProvider generator = originalSource.create(originalSeed, originalArgs);
        Assertions.assertEquals(generator.getClass(), rng.getClass());
    }

    /**
     * Test the factory create method returns the same class as the instance create method
     * and produces the same output.
     */
    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testFactoryCreateMethodWithSeed(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object originalSeed = data.getSeed();
        final Object[] originalArgs = data.getArgs();
        final UniformRandomProvider generator = originalSource.create(originalSeed, originalArgs);
        @SuppressWarnings("deprecation")
        final UniformRandomProvider rng1 = RandomSource.create(originalSource, originalSeed, originalArgs);
        Assertions.assertEquals(rng1.getClass(), generator.getClass());
        // Check the output
        final UniformRandomProvider rng2 = originalSource.create(originalSeed, originalArgs);
        for (int i = 0; i < 10; i++) {
            Assertions.assertEquals(rng2.nextLong(), rng1.nextLong());
        }
    }

    /**
     * Test the create method throws an {@link IllegalArgumentException} if passed the wrong
     * arguments.
     */
    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testCreateMethodThrowsWithIncorrectArguments(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        if (originalArgs == null) {
            // Try passing arguments to a provider that does not require them
            final int arg1 = 123;
            final double arg2 = 456.0;
            Assertions.assertThrows(IllegalArgumentException.class,
                () -> originalSource.create(arg1, arg2),
                () -> "Source does not require arguments: " + originalSource);
        } else {
            // Try no arguments for a provider that does require them
            Assertions.assertThrows(IllegalArgumentException.class,
                originalSource::create,
                () -> "Source requires arguments: " + originalSource);
        }
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testAllSeedTypes(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object originalSeed = data.getSeed();
        final Object[] originalArgs = data.getArgs();
        final Integer intSeed = -12131415;
        final Long longSeed = -1213141516171819L;
        final int[] intArraySeed = new int[] {0, 11, -22, 33, -44, 55, -66, 77, -88, 99};
        final long[] longArraySeed = new long[] {11111L, -222222L, 3333333L, -44444444L};
        final byte[] byteArraySeed = new byte[] {-128, -91, -45, -32, -1, 0, 11, 23, 54, 88, 127};

        final Object[] seeds = new Object[] {null,
                                             intSeed,
                                             longSeed,
                                             intArraySeed,
                                             longArraySeed,
                                             byteArraySeed};

        int nonNativeSeedCount = 0;
        int seedCount = 0;
        for (final Object s : seeds) {
            ++seedCount;
            if (originalSource.isNativeSeed(s)) {
                Assertions.assertNotNull(s, "Identified native seed is null");
                Assertions.assertEquals(s.getClass(), originalSeed.getClass(),
                    "Incorrect identification of native seed type");
            } else {
                ++nonNativeSeedCount;
            }

            originalSource.create(s, originalArgs);
        }

        Assertions.assertEquals(6, seedCount);
        Assertions.assertEquals(5, nonNativeSeedCount);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testNullSeed(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        // Note: This is the only test that explicitly calls RandomSource.create() with no other arguments.
        final UniformRandomProvider rng = originalArgs == null ?
            originalSource.create() :
            originalSource.create(null, originalArgs);
        checkNextIntegerInRange(rng, 10, 10000);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testEmptyIntArraySeed(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        final int[] empty = new int[0];
        Assumptions.assumeTrue(originalSource.isNativeSeed(empty));

        // Exercise the default seeding procedure.
        final UniformRandomProvider rng = originalSource.create(empty, originalArgs);
        checkNextIntegerInRange(rng, 10, 20000);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testEmptyLongArraySeed(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        final long[] empty = new long[0];
        Assumptions.assumeTrue(originalSource.isNativeSeed(empty));

        // Exercise the default seeding procedure.
        final UniformRandomProvider rng = originalSource.create(empty, originalArgs);
        checkNextIntegerInRange(rng, 10, 10000);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testZeroIntArraySeed(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        // Exercise capacity to escape all "zero" state.
        final int[] zero = new int[2000]; // Large enough to fill the entire state with zeroes.
        final UniformRandomProvider rng = originalSource.create(zero, originalArgs);
        Assumptions.assumeTrue(createsNonZeroLongOutput(rng, 2000),
            () -> "RNG is non-functional with an all zero seed: " + originalSource);
        checkNextIntegerInRange(rng, 10, 10000);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testZeroLongArraySeed(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        // Exercise capacity to escape all "zero" state.
        final long[] zero = new long[2000]; // Large enough to fill the entire state with zeroes.
        final UniformRandomProvider rng = originalSource.create(zero, originalArgs);
        Assumptions.assumeTrue(createsNonZeroLongOutput(rng, 2000),
            () -> "RNG is non-functional with an all zero seed: " + originalSource);
        checkNextIntegerInRange(rng, 10, 10000);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testRandomSourceCreateSeed(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        final byte[] seed = originalSource.createSeed();
        final UniformRandomProvider rng = originalSource.create(seed, originalArgs);
        checkNextIntegerInRange(rng, 10, 10000);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testRandomSourceCreateSeedFromRNG(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        final byte[] seed = originalSource.createSeed(new SplitMix64(RandomSource.createLong()));
        final UniformRandomProvider rng = originalSource.create(seed, originalArgs);
        checkNextIntegerInRange(rng, 10, 10000);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testRandomSourceCreateSeedFromInvalidRNG(ProvidersList.Data data) {
        // Create a RNG that will fill a byte[] seed with all zeros.
        // The ensure non-zero range checks in the RandomSource should
        // create a good seed and a functional RNG.
        final LongProvider badRng = new LongProvider() {
            @Override
            public long next() {
                return 0;
            }
        };

        final RandomSource originalSource = data.getSource();
        final byte[] seed = originalSource.createSeed(badRng);

        // The seed generation should be repeatable
        Assertions.assertArrayEquals(seed, originalSource.createSeed(badRng));

        // The RNG seed will create a functional generator
        final Object[] originalArgs = data.getArgs();
        final UniformRandomProvider rng = originalSource.create(seed, originalArgs);
        checkNextIntegerInRange(rng, 10, 10000);
    }

    // State save and restore tests.

    @SuppressWarnings("unused")
    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testUnrestorable(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object originalSeed = data.getSeed();
        final Object[] originalArgs = data.getArgs();
        // Create two generators of the same type as the one being tested.
        final UniformRandomProvider rng1 = originalSource.create(originalSeed, originalArgs);
        final UniformRandomProvider rng2 = RandomSource.unrestorable(originalSource.create(originalSeed, originalArgs));

        // Ensure that they generate the same values.
        RandomAssert.assertProduceSameSequence(rng1, rng2);

        // Cast must work.
        final RestorableUniformRandomProvider restorable = (RestorableUniformRandomProvider) rng1;
        // Cast must fail.
        Assertions.assertThrows(ClassCastException.class, () -> {
            final RestorableUniformRandomProvider dummy = (RestorableUniformRandomProvider) rng2;
        });
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testSerializingState(ProvidersList.Data data)
        throws IOException,
               ClassNotFoundException {
        final UniformRandomProvider generator = data.getSource().create(data.getSeed(), data.getArgs());

        // Large "n" is not necessary here as we only test the serialization.
        final int n = 100;

        // Cast is OK: all instances created by this library inherit from "BaseProvider".
        final RestorableUniformRandomProvider restorable = (RestorableUniformRandomProvider) generator;

        // Save.
        final RandomProviderState stateOrig = restorable.saveState();
        // Serialize.
        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
        final ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(((RandomProviderDefaultState) stateOrig).getState());

        // Store some values.
        final List<Number> listOrig = makeList(n, generator);

        // Discard a few more.
        final List<Number> listDiscard = makeList(n, generator);
        Assertions.assertNotEquals(0, listDiscard.size());
        Assertions.assertNotEquals(listOrig, listDiscard);

        // Retrieve from serialized stream.
        final ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        final ObjectInputStream ois = new ObjectInputStream(bis);
        final RandomProviderState stateNew = new RandomProviderDefaultState((byte[]) ois.readObject());

        Assertions.assertNotSame(stateOrig, stateNew);

        // Reset.
        restorable.restoreState(stateNew);

        // Replay.
        final List<Number> listReplay = makeList(n, generator);
        Assertions.assertNotSame(listOrig, listReplay);

        // Check that the serialized data recreated the orginal state.
        Assertions.assertEquals(listOrig, listReplay);
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testUnrestorableToString(ProvidersList.Data data) {
        final UniformRandomProvider generator = data.getSource().create(data.getSeed(), data.getArgs());
        Assertions.assertEquals(generator.toString(),
                                RandomSource.unrestorable(generator).toString());
    }

    @ParameterizedTest
    @MethodSource("getProvidersTestData")
    void testSupportedInterfaces(ProvidersList.Data data) {
        final RandomSource originalSource = data.getSource();
        final Object[] originalArgs = data.getArgs();
        final UniformRandomProvider rng = originalSource.create(null, originalArgs);
        Assertions.assertEquals(rng instanceof JumpableUniformRandomProvider,
                                originalSource.isJumpable(),
                                "isJumpable");
        Assertions.assertEquals(rng instanceof LongJumpableUniformRandomProvider,
                                originalSource.isLongJumpable(),
                                "isLongJumpable");
        Assertions.assertEquals(rng instanceof ArbitrarilyJumpableUniformRandomProvider,
                                originalSource.isArbitrarilyJumpable(),
                                "isArbitrarilyJumpable");
        Assertions.assertEquals(rng instanceof SplittableUniformRandomProvider,
                                originalSource.isSplittable(),
                                "isSplittable");
    }

    ///// Support methods below.


    // The methods
    //   * makeList
    //   * checkNextIntegerInRange
    //   * checkNextInRange
    // have been copied from "src/test" in module "commons-rng-core".

    /**
     * Populates a list with random numbers.
     *
     * @param n Loop counter.
     * @param generator Random generator.
     * @return a list containing {@code 11 * n} random numbers.
     */
    private static List<Number> makeList(int n, UniformRandomProvider generator) {
        final List<Number> list = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            // Append 11 values.
            list.add(generator.nextInt());
            list.add(generator.nextInt(21));
            list.add(generator.nextInt(436));
            list.add(generator.nextLong());
            list.add(generator.nextLong(157894));
            list.add(generator.nextLong(5745833));
            list.add(generator.nextFloat());
            list.add(generator.nextFloat());
            list.add(generator.nextDouble());
            list.add(generator.nextDouble());
            list.add(generator.nextBoolean() ? 1 : 0);
        }

        return list;
    }

    /**
     * Tests uniformity of the distribution produced by {@code nextInt(int)}.
     *
     * @param rng Generator.
     * @param max Upper bound.
     * @param sampleSize Number of random values generated.
     * @param generator Random generator.
     */
    private static void checkNextIntegerInRange(final UniformRandomProvider rng,
                                                final int max,
                                                int sampleSize) {
        final LongSupplier nextMethod = () -> rng.nextInt(max);

        checkNextInRange(rng, max, sampleSize, nextMethod);
    }

    /**
     * Tests uniformity of the distribution produced by the given
     * {@code nextMethod}.
     * It performs a chi-square test of homogeneity of the observed
     * distribution with the expected uniform distribution.
     * Repeat tests are performed at the 1% level and the total number of failed
     * tests is tested at the 0.5% significance level.
     *
     * @param n Upper bound.
     * @param nextMethod method to call.
     * @param sampleSize Number of random values generated.
     * @param generator Random generator.
     */
    private static void checkNextInRange(UniformRandomProvider generator,
                                         long n,
                                         int sampleSize,
                                         LongSupplier nextMethod) {
        final int numTests = 500;

        // Do not change (statistical test assumes that dof = 9).
        final int numBins = 10; // dof = numBins - 1

        // Set up bins.
        final long[] binUpperBounds = new long[numBins];
        final double step = n / (double) numBins;
        for (int k = 0; k < numBins; k++) {
            binUpperBounds[k] = (long) ((k + 1) * step);
        }
        // Rounding error occurs on the long value of 2305843009213693951L
        binUpperBounds[numBins - 1] = n;

        // Run the tests.
        int numFailures = 0;

        final double[] expected = new double[numBins];
        long previousUpperBound = 0;
        for (int k = 0; k < numBins; k++) {
            final long range = binUpperBounds[k] - previousUpperBound;
            expected[k] = sampleSize * (range / (double) n);
            previousUpperBound = binUpperBounds[k];
        }

        final int[] observed = new int[numBins];
        // Chi-square critical value with 9 degrees of freedom
        // and 1% significance level.
        final double chi2CriticalValue = 21.665994333461924;

        // For storing chi2 larger than the critical value.
        final List<Double> failedStat = new ArrayList<>();
        try {
            final int lastDecileIndex = numBins - 1;
            for (int i = 0; i < numTests; i++) {
                Arrays.fill(observed, 0);
                SAMPLE: for (int j = 0; j < sampleSize; j++) {
                    final long value = nextMethod.getAsLong();
                    Assertions.assertTrue(value >= 0 && value < n, "Range");

                    for (int k = 0; k < lastDecileIndex; k++) {
                        if (value < binUpperBounds[k]) {
                            ++observed[k];
                            continue SAMPLE;
                        }
                    }
                    ++observed[lastDecileIndex];
                }

                // Compute chi-square.
                double chi2 = 0;
                for (int k = 0; k < numBins; k++) {
                    final double diff = observed[k] - expected[k];
                    chi2 += diff * diff / expected[k];
                }

                // Statistics check.
                if (chi2 > chi2CriticalValue) {
                    failedStat.add(chi2);
                    ++numFailures;
                }
            }
        } catch (final Exception e) {
            // Should never happen.
            throw new RuntimeException("Unexpected", e);
        }

        // The expected number of failed tests can be modelled as a Binomial distribution
        // B(n, p) with n=500, p=0.01 (500 tests with a 1% significance level).
        // The cumulative probability of the number of failed tests (X) is:
        // x     P(X>x)
        // 10    0.0132
        // 11    0.00521
        // 12    0.00190

        if (numFailures > 11) { // Test will fail with 0.5% probability
            Assertions.fail(String.format(
                    "%s: Too many failures for n = %d, sample size = %d " +
                    "(%d out of %d tests failed, chi2 > %.3f=%s)",
                    generator, n, sampleSize, numFailures, numTests, chi2CriticalValue,
                    failedStat.stream().map(d -> String.format("%.3f", d))
                              .collect(Collectors.joining(", ", "[", "]"))));
        }
    }

    /**
     * Return true if the generator creates non-zero output from
     * {@link UniformRandomProvider#nextLong()} within the given number of cycles.
     *
     * @param rng Random generator.
     * @param cycles Number of cycles.
     * @return true if non-zero output
     */
    private static boolean createsNonZeroLongOutput(UniformRandomProvider rng,
                                                    int cycles) {
        boolean nonZero = false;
        for (int i = 0; i < cycles; i++) {
            if (rng.nextLong() != 0) {
                nonZero = true;
            }
        }
        return nonZero;
    }
}
