package net.coderodde.util;

import java.util.Arrays;
import java.util.Random;

/**
 * This class facilitates creation of random integer arrays using a fluent API.
 *
 * @author Rodion "rodde" Efremov
 * @version 1.6 (Sep 11, 2015)
 */
public class FluentArrays {

    /**
     * This inner static class is responsible for choosing between integers and
     * long integers.
     */
    public static class TypeSelector {

        /**
         * Chooses long integers and returns the array length selector.
         *
         * @return the array length selector.
         */
        public LongLengthSelector ofLongs() {
            return new LongLengthSelector();
        }

        /**
         * Chooses integers and returns the array length selector.
         *
         * @return the array length selector.
         */
        public IntLengthSelector ofIntegers() {
            return new IntLengthSelector();
        }
    }

    /**
     * This inner static class is responsible for choosing the length of a long
     * integer array.
     */
    public static class LongLengthSelector {

        /**
         * Chooses the array length and returns the minimum value selector.
         *
         * @param  length the length of the array.
         * @return the minimum value selector.
         */
        public LongMinimumSelector ofLength(int length) {
            checkLength(length);
            return new LongMinimumSelector(length);
        }
    }

    /**
     * This inner static class is responsible for choosing the length of an
     * integer array.
     */
    public static class IntLengthSelector {

        /**
         * Chooses the array length and returns the minimum value selector.
         *
         * @param  length the length of the array.
         * @return the minimum value selector.
         */
        public IntMinimumSelector ofLength(int length) {
            checkLength(length);
            return new IntMinimumSelector(length);
        }
    }

    /**
     * This inner static class is responsible for choosing the minimum value of
     * an array of long integers.
     */
    public static class LongMinimumSelector {

        /**
         * The length of the requested array.
         */
        private final int length;

        private LongMinimumSelector(int length) {
            this.length = length;
        }

        /**
         * Selects the value of the minimum array component.
         *
         * @param  minimum the minimum value allowed.
         * @return the maximum value selector.
         */
        public LongMaximumSelector withMinimum(long minimum) {
            return new LongMaximumSelector(length, minimum);
        }
    }

    /**
     * This inner static class is responsible for choosing the minimum value of
     * an array of integers.
     */
    public static class IntMinimumSelector {

        /**
         * The length of the requested array.
         */
        private final int length;

        private IntMinimumSelector(int length) {
            this.length = length;
        }

        /**
         * Selects the value of the minimum array component.
         *
         * @param  minimum the minimum value allowed.
         * @return the maximum value selector.
         */
        public IntMaximumSelector withMinimum(int minimum) {
            return new IntMaximumSelector(length, minimum);
        }
    }

    /**
     * This inner static class is responsible for choosing the maximum value of
     * an array of long integers.
     */
    public static class LongMaximumSelector {

        /**
         * The length of the requested array.
         */
        private final int length;

        /**
         * The minimum requested value.
         */
        private final long minimum;

        private LongMaximumSelector(int length, long minimum) {
            this.length = length;
            this.minimum = minimum;
        }

        /**
         * Selects the value of the maximum array component.
         *
         * @param  maximum the maximum value allowed.
         * @return the random number generator selector.
         */
        public LongRandomSelector withMaximum(long maximum) {
            checkMinMax(minimum, maximum);
            return new LongRandomSelector(length, minimum, maximum);
        }
    }

    /**
     * This inner static class is responsible for choosing the maximum value of
     * an array of integers.
     */
    public static class IntMaximumSelector {

        /**
         * The length of the requested array.
         */
        private final int length;

        /**
         * The minimum requested value.
         */
        private final int minimum;

        private IntMaximumSelector(int length, int minimum) {
            this.length = length;
            this.minimum = minimum;
        }

        /**
         * Selects the value of the maximum array component.
         *
         * @param  maximum the maximum value allowed.
         * @return the random number generator selector.
         */
        public IntRandomSelector withMaximum(int maximum) {
            checkMinMax(minimum, maximum);
            return new IntRandomSelector(length, minimum, maximum);
        }
    }

    /**
     * This inner static class is responsible for creating the actual long
     * integer arrays.
     */
    public static class LongRandomSelector {

        /**
         * The length of the requested array.
         */
        private final int length;

        /**
         * The minimum requested value.
         */
        private final long minimum;

        /**
         * The maximum requested value.
         */
        private final long maximum;

        private LongRandomSelector(int length,
                                   long minimum,
                                   long maximum) {
            this.length = length;
            this.minimum = minimum;
            this.maximum = maximum;
        }

        /**
         * Creates the actual array of long integers using a specified random
         * number generator.
         *
         * @param  random the random number generator.
         * @return the array of long integers.
         */
        public long[] withRandom(Random random) {
            final long[] array = new long[length];

            for (int i = 0; i < length; ++i) {
                array[i] = Math.abs(random.nextLong()) %
                           (maximum - minimum + 1) + minimum;
            }

            return array;
        }

        /**
         * Create the actual array of long integers using a default random
         * number generator.
         *
         * @return the array of long integers.
         */
        public long[] withDefaultRandom() {
            return withRandom(new Random());
        }
    }

    /**
     * This inner static class is responsible for creating the actual integer
     * arrays.
     */
    public static class IntRandomSelector {

        /**
         * The length of the requested array.
         */
        private final int length;

        /**
         * The minimum requested value.
         */
        private final int minimum;

        /**
         * The maximum requested value.
         */
        private final int maximum;

        private IntRandomSelector(int length,
                                  int minimum,
                                  int maximum) {
            this.length = length;
            this.minimum = minimum;
            this.maximum = maximum;
        }

        /**
         * Creates the actual array of integers using a specified random number
         * generator.
         *
         * @param  random the random number generator.
         * @return the array of integers.
         */
        public int[] withRandom(Random random) {
            final int[] array = new int[length];

            for (int i = 0; i < length; ++i) {
                array[i] = random.nextInt(maximum - minimum + 1) + minimum;
            }

            return array;
        }

        /**
         * Creates the actual array of integers using a default random number
         * generator.
         *
         * @return the array of integers.
         */
        public int[] withDefaultRandom() {
            return withRandom(new Random());
        }
    }

    /**
     * This class is responsible for initiating a fluent API call.
     *
     * @return the type selector.
     */
    public static TypeSelector createArray() {
        return new TypeSelector();
    }

    private static void checkLength(int length) {
        if (length < 0) {
            throw new IllegalArgumentException(
                    "The requested length is negative (" + length + ").");
        }
    }

    private static void checkMinMax(int a, int b) {
        if (a > b) {
            throw new IllegalArgumentException(
                    "The requested minimum value " +
                    "(" + a + ") is greater than the maximum (" + b + ").");
        }
    }

    private static void checkMinMax(long a, long b) {
        if (a > b) {
            throw new IllegalArgumentException(
                    "The requested minimum value " +
                    "(" + a + ") is greater than the maximum (" + b + ").");
        }
    }

    public static void main(String[] args) {
        long[] array1 = createArray().ofLongs()
                                     .ofLength(12)
                                     .withMinimum(-100L)
                                     .withMaximum(200L)
                                     .withDefaultRandom();

        System.out.println(Arrays.toString(array1));

        int[] array2 = createArray().ofIntegers()
                                    .ofLength(15)
                                    .withMinimum(-10)
                                    .withMaximum(20)
                                    .withDefaultRandom();

        System.out.println(Arrays.toString(array2));
    }
}

long[] array1 = createArray().ofLongs()
                 .ofLength(12)
                 .withMinimum(-100L)
                 .withMaximum(200L)
                 .withDefaultRandom();

long[] array = ThreadLocalRandom.longs(12, -100, 200).toArray();

Random rand = new Random();
long[] more = rand.longs(12, -100, 200).toArray();

long[] more = rand.longs(-100, 200).limit(12).toArray();

int[] ints = rand.ints(-100, 200).limit(12).toArray();