import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;

abstract public class NumericStreamFactory {

    private NumericStreamFactory() {
        throw new IllegalStateException("Not expecting to create instances of this class");
    }

    public static Stream<Long> getFibonacciStreamOfLongValues() {

        return Stream.generate(new Supplier<Long>() {

            private int _elementNumber = 0;
            private long _priorValueOne = 0;
            private long _priorValueTwo = 0;
            private boolean _exceedsLongValue = false;

            @Override
            public Long get() {
                ++_elementNumber;

                final long nextValue = _priorValueOne + ((_priorValueTwo == 0) ? 1 : _priorValueTwo);
                _priorValueOne = _priorValueTwo;
                _priorValueTwo = nextValue;

                if (nextValue < 0 || _exceedsLongValue) {
                    _exceedsLongValue = true;
                    throw new NoSuchElementException("Fibonacci element number " + _elementNumber + " exceeds the maximum value that can be held in a Java 'long' type.");
                }

                return nextValue;
            }
        });
    }

    public static Stream<BigInteger> getFibonacciStreamOfBigIntegerValues() {

        return Stream.generate(new Supplier<BigInteger>() {

            private BigInteger _priorValueOne = null;
            private BigInteger _priorValueTwo = BigInteger.ZERO;

            @Override
            public BigInteger get() {

                final BigInteger nextValue;
                if (_priorValueOne == null) {
                    nextValue = BigInteger.ONE;
                } else {
                    nextValue = _priorValueOne.add(_priorValueTwo);
                }

                _priorValueOne = _priorValueTwo;
                _priorValueTwo = nextValue;

                return nextValue;
            }
        });
    }

    public static Stream<Integer> getPrimeStream() {
        return Stream.generate(new Supplier<Integer>() {
            private int _lastPrime = 2 - 1;  // = one before the first known prime number
            private List<Integer> _primeNumbers = new ArrayList<>();
            @Override
            public Integer get() {
                int candidatePrime = _lastPrime + 1;
                boolean tryAnotherNumber = true;
                while (tryAnotherNumber) {
                    tryAnotherNumber = false;
                    for (final Integer factor : _primeNumbers) {
                        if (candidatePrime % factor == 0) {
                            ++candidatePrime;
                            tryAnotherNumber = true;
                            break;
                        }
                    }
                }
                _primeNumbers.add(candidatePrime);
                _lastPrime = candidatePrime;
                return candidatePrime;
            }
        });
    }

    public static Stream<Long> getCombinedStreamOfLongValues() {

        return Stream.generate(new Supplier<Long>() {

            private boolean nextIsPrime = false;
            final Iterator<Long> fibonacciStreamIterator = getFibonacciStreamOfLongValues().iterator();
            final Iterator<Integer> primeStreamIterator = getPrimeStream().iterator();

            @Override
            public Long get() {
                if (nextIsPrime) {
                    nextIsPrime = false;
                    return (long) primeStreamIterator.next();
                } else {
                    nextIsPrime = true;
                    return fibonacciStreamIterator.next();
                }
            }
        });
    }

    public static Stream<BigInteger> getCombinedStreamOfBigIntegerValues() {

        return Stream.generate(new Supplier<BigInteger>() {

            private boolean nextIsPrime = false;
            final Iterator<BigInteger> fibonacciStreamIterator = getFibonacciStreamOfBigIntegerValues().iterator();
            final Iterator<Integer> primeStreamIterator = getPrimeStream().iterator();

            @Override
            public BigInteger get() {
                if (nextIsPrime) {
                    nextIsPrime = false;
                    return new BigInteger(String.valueOf(primeStreamIterator.next()));
                } else {
                    nextIsPrime = true;
                    return fibonacciStreamIterator.next();
                }
            }
        });
    }

}