package Torello.Java.JSON;

import Torello.Java.StringParse;
import Torello.Java.UnreachableError;

import Torello.Java.Additional.Counter;

import java.lang.reflect.Array;

import java.util.function.Function;
import java.util.function.ObjIntConsumer;

import java.util.stream.Stream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.DoubleStream;

import javax.json.JsonArray;
import javax.json.JsonValue;

import static javax.json.JsonValue.ValueType.*;

class GENERATE_1DARRAY
{
    // @SuppressWarnings({"unchecked", "rawtypes"})
    @SuppressWarnings("unchecked")
    static <T> Function<JsonArray, Object> retrieveAppropriateGenerator(
            final SettingsRec<?, ?> rec,
            final BASIC_TYPES<T>    bt,
            final boolean           boxedOrPrimitive
        )
    {
        switch (bt.whichType)
        {
            case BASIC_TYPES.INTEGER: return boxedOrPrimitive 

                ? (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Integer, Stream<Integer>>) rec)
                    .toArray(Integer[]::new)

                : (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Integer, IntStream>) rec)
                    .toArray();


            case BASIC_TYPES.SHORT: return boxedOrPrimitive

                ? (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Short, Stream<Short>>) rec)
                    .toArray(Short[]::new)

                : (JsonArray ja) ->
                    array1DGeneratorShort(ja, (SettingsRec<Short, Stream<Short>>) rec);


            case BASIC_TYPES.BYTE: return boxedOrPrimitive

                ? (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Byte, Stream<Byte>>) rec)
                    .toArray(Byte[]::new)

                : (JsonArray ja) ->
                    array1DGeneratorByte(ja, (SettingsRec<Byte, Stream<Byte>>) rec);


            case BASIC_TYPES.LONG: return boxedOrPrimitive

                ? (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Long, Stream<Long>>) rec)
                    .toArray(Long[]::new)

                : (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Long, LongStream>) rec)
                    .toArray();


            case BASIC_TYPES.DOUBLE: return boxedOrPrimitive

                ? (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Double, Stream<Double>>) rec)
                    .toArray(Double[]::new)

                : (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Double, DoubleStream>) rec)
                    .toArray();


            case BASIC_TYPES.FLOAT: return boxedOrPrimitive

                ? (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Float, Stream<Float>>) rec)
                    .toArray(Float[]::new)

                : (JsonArray ja) ->
                    array1DGeneratorFloat(ja, (SettingsRec<Float, Stream<Float>>) rec);


            case BASIC_TYPES.BOOLEAN: return boxedOrPrimitive

                ? (JsonArray ja) -> ProcessJsonArray
                    .booleanToJava(ja, (SettingsRec<Boolean, Stream<Boolean>>) rec)
                    .toArray(Boolean[]::new)

                : (JsonArray ja) ->
                    array1DGeneratorBoolean(ja, (SettingsRec<Boolean, Stream<Boolean>>) rec);


            case BASIC_TYPES.NUMBER:

                return (JsonArray ja) -> ProcessJsonArray
                    .numericToJava(ja, (SettingsRec<Number, Stream<Number>>) rec)
                    .toArray(Number[]::new);


            case BASIC_TYPES.STRING:

                return (JsonArray ja) -> ProcessJsonArray
                    .strToJava(ja, (SettingsRec<String, Stream<String>>) rec)
                    .toArray(String[]::new);


            case BASIC_TYPES.OBJECT:

                return (JsonArray ja) -> ProcessJsonArray
                        .objToJava(ja, (SettingsRec<T, Stream<T>>) rec)
                        .toArray((int length) -> (T[]) Array.newInstance(rec.CLASS, length));

            default: throw new UnreachableError();
        }
    }


    // Converts a Java Boxed Stream to a Primitive Array.
    static <T, U> U boxedStreamToPrimitiveArray(
            final Stream<T>         boxedStream,
            final JsonArray         ja,
            final Class<T>          returnClass,
            final ObjIntConsumer<T> arrayBuilder,
            final U                 retArr
        )
    {
        // Since the array-index is used inside of a LAMBDA, this "EffectivelyFinal" counter
        // class becomes necessary.

        final Counter counter = new Counter(-1);

        // Don't forget, Stream's are not guaranteed to be processed in order, unless an
        // explicit request is made using something like 'forEachOrdered'

        boxedStream.forEachOrdered((T boxedPrimitive) ->
        {
            final int i = counter.addOne(); // "Final, or Effectively Final"

            // A Primitive-Array (like int[], long[], boolean[] etc...) may not have null
            if (boxedPrimitive == null)
                throw new JsonNullPrimitiveArrException(ja, i, NUMBER, returnClass);

            // The 'arrayBuilder' just assigns the value to the array[i]
            arrayBuilder.accept(boxedPrimitive, i);
        });
    
        return retArr;
    }

    
    // REMEMBER: The 1-D Arrays ==> int[], long[], double[] are built directly from a 
    //           PrimitiveStream using PrimStream.toArray, they don't need a "helper"


    // @SuppressWarnings({"rawtypes", "unchecked"})
    private static short[] array1DGeneratorShort(
            final JsonArray                         ja,
            final SettingsRec<Short, Stream<Short>> rec
        )
    {
        final short[] retArrShort = new short[ja.size()];

        return boxedStreamToPrimitiveArray(
            ProcessJsonArray.numericToJava(ja, rec),
            ja,
            short.class,
            (Short s, int i) -> retArrShort[i] = s.shortValue(),
            retArrShort
        );
    }


    // @SuppressWarnings({"rawtypes", "unchecked"})
    private static byte[] array1DGeneratorByte(
            final JsonArray                         ja,
            final SettingsRec<Byte, Stream<Byte>>   rec
        )
    {
        final byte[] retArrByte = new byte[ja.size()];

        return boxedStreamToPrimitiveArray(
            ProcessJsonArray.numericToJava(ja, rec),
            ja,
            byte.class,
            (Byte s, int i) -> retArrByte[i] = s.byteValue(),
            retArrByte
        );
    }


    // @SuppressWarnings({"rawtypes", "unchecked"})
    private static float[] array1DGeneratorFloat(
            final JsonArray                         ja,
            final SettingsRec<Float, Stream<Float>> rec
        )
    {
        final float[] retArrFloat = new float[ja.size()];

        return boxedStreamToPrimitiveArray(
            ProcessJsonArray.numericToJava(ja, rec),
            ja,
            float.class,
            (Float s, int i) -> retArrFloat[i] = s.floatValue(),
            retArrFloat
        );
    }


    // @SuppressWarnings({"rawtypes", "unchecked"})
    private static boolean[] array1DGeneratorBoolean(
            final JsonArray                             ja,
            final SettingsRec<Boolean, Stream<Boolean>> rec
        )
    {
        final boolean[] retArrBoolean = new boolean[ja.size()];

        return boxedStreamToPrimitiveArray(
            ProcessJsonArray.booleanToJava(ja, rec),
            ja,
            boolean.class,
            (Boolean s, int i) -> retArrBoolean[i] = s.booleanValue(),
            retArrBoolean
        );
    }

}