package Torello.JSON;

import Torello.Java.StringParse;

import java.lang.reflect.Array;

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

import java.util.Arrays;
import java.util.Objects;

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

@Torello.JavaDoc.Annotations.StaticFunctional
public class ProcessMultiDimJsonArray
{
    private ProcessMultiDimJsonArray() { }

    /**
     * This class is invoked by the class {@link RJArrDimN}
     * 
     * @param <BASIC_TYPE> The "Component Type" of the Output-Array.
     * 
     * @param <STREAM_TYPE> The "Intermediate Stream Type", which is present before the conversion
     * to an Array.
     * 
     * @param <RETURN_ARR_TYPE> The actual Return-Type of the method.  This must be an Array-Class,
     * such as {@code int[][].class} or (in the case of Boxed-Type Arrays) {@code Integer[][]}.
     * 
     * @param ja Any instance of {@link JsonArray}.  The contents sof this array should match the 
     * dimensionality of the expected Output-Array Type, or an exception will likelyy throw.
     * 
     * @param rec An instance of {@link SettingsRec} that's been configured to return a 
     * multi-dimensional array.
     * 
     * @param retArrClass The class of the return array.
     * @return An instance of {@code 'retArrClass'}
     */
    public static <BASIC_TYPE, STREAM_TYPE, RETURN_ARR_TYPE> RETURN_ARR_TYPE jsonArrayToJava(
            final JsonArray                             ja,
            final SettingsRec<BASIC_TYPE, STREAM_TYPE>  rec,
            final Class<RETURN_ARR_TYPE>                retArrClass
        )
    {
        CHECK_ARRAY_CLASS(retArrClass, rec.CLASS);
        return jsonArrayToJava_INTERNAL(ja, rec, retArrClass);
    }

    @SuppressWarnings("unchecked")
    private static <BASIC_TYPE, STREAM_TYPE, RETURN_ARR_TYPE> RETURN_ARR_TYPE
        jsonArrayToJava_INTERNAL(
            final JsonArray                             ja,
            final SettingsRec<BASIC_TYPE, STREAM_TYPE>  rec,
            final Class<RETURN_ARR_TYPE>                retArrClass
        )
    {
        /*
        System.out.println(
            "TOP-OF-METHOD-PART INTERIM PRINTING:\n" +
            "retArrClass.getSimpleName():       " + retArrClass.getSimpleName() + '\n' +
            "ja.toString():                     " + ja.toString()
        );
        */

        // If this is requesting a one-dimensional array, get it using the 1D-Generator,
        // and simply return that array.  This requires a cast because there is no way to prove
        // to the Java-Compiler that <T> is equal to any return-value at all.
        //
        // Remember that this is only guaranteed (it works!) because the helper methods are all
        // protected or private, and it has been guaranteed through rigorous testing, and
        // preventing the user from playing with it!

        if (StringParse.countCharacters(retArrClass.getSimpleName(), '[') == 1)
            return (RETURN_ARR_TYPE) rec.array1DGenerator.apply(ja);


        // Otherwise, this is not a single-dimension (1D) array.  Instead, the JsonArray needs
        // to be iterated, and this method called, recursively, on each of the sub-arrays.
        //
        // NOTE: 'compClass' will also be an array, but with one fewer dimensions

        final Class<?>  componentClass  = retArrClass.getComponentType();
        final int       SIZE            = ja.size();


        // This generates an instance of the "Array Component Type".  All that means is that this
        // new array has one fewer set of brackets.  int[][] would become int[]

        final RETURN_ARR_TYPE retArr = (RETURN_ARR_TYPE) Array.newInstance(componentClass, SIZE);

        JsonValue jv = null;

        for (int i=0; i < SIZE; i++)

            switch ((jv = ja.get(i)).getValueType())
            {
                // javax.json.JsonValue.ValueType.NULL
                case NULL: Array.set(retArr, i, null); break;

                // javax.json.JsonValue.ValueType.ARRAY (JsonArray)
                case ARRAY:

                    final Object newArr =
                        jsonArrayToJava_INTERNAL((JsonArray) jv, rec, componentClass);

                    /*
                    // assign these variables using some kind of "if-then-else" and "toString"
                    // In order to use java.util.Arrays.toString(), you will need to actual type of
                    // othese objects, and those Parameterized Types are not easy to use with
                    // java.util.Arrays

                    final String RET_ARR_STR, NEW_ARR_STR;

                    System.out.println(
                        "retArrClass: " + retArrClass.getSimpleName()       + '\n' +
                        "retArr:      " + RET_ARR_STR                       + '\n' +
                        "compClass:   " + componentClass.getSimpleName()    + '\n' +
                        "newArr:      " + NEW_ARR_STR                       + '\n' +
                        "i:           " + i                                 + '\n' +
                        "SIZE:        " + SIZE                              + '\n' +
                        "jv:          " + jv.toString()                     + '\n'
                    );
                    */

                    Array.set(retArr, i, newArr);

                    break;

                // javax.json.JsonValue.ValueType.TRUE, FALSE, NUMBER, STRING, OBJECT
                default:

                    if (rec.IN_NSAT)        Array.set(retArr, i, null);
                    else if (rec.S_NSAT)    continue;
                    else throw new JsonTypeArrException(ja, i, ARRAY, jv, retArrClass);
            }

        return retArr;
    }



    // ********************************************************************************************
    // ********************************************************************************************
    // One Helper
    // ********************************************************************************************
    // ********************************************************************************************


    /**
     * Check user input, and throws exceptions if the array-class has not been properly
     * chosen.
     * 
     * @param retArrClass This must be a primitive-array class, possibly of multiple dimensions
     * 
     * @param expectedRootClass The expected "root class".  For {@code int[][].class}, the root
     * class would be {@code int.class}.
     * 
     * @return Parameter {@code retArrClass} is the return value of this checker method
     * 
     * @throws IllegalArgumentExcetion If parameter retArrClass:
     * If calling retArrClass.isArray() returns FALSE
     * If the root-array type is not the appropriate type for the method that was called
     */
    protected static <T> Class<T> CHECK_ARRAY_CLASS(
            final Class<T> retArrClass,
            final Class<?> expectedRootClass
        )
    {
        Objects.requireNonNull(retArrClass, "Return-Array Type, Parameter 'retArrClass' is null");

        if (! retArrClass.isArray()) throw new IllegalArgumentException(
            "The class you have passed to parameter 'retArrClass' " +
            "[" + retArrClass.getSimpleName() + "], is not an array"
        );

        Class<?> componentClass = retArrClass.getComponentType();

        while (componentClass.isArray()) componentClass = componentClass.getComponentType();

        if (! expectedRootClass.equals(componentClass)) throw new IllegalArgumentException(
            "The class you have passed to parameter 'retArrClass' " +
            "[" + retArrClass.getSimpleName() + "], is not a(n) " +
            expectedRootClass.getSimpleName() + "-array."
        );

        return retArrClass;
    }
}