package Torello.Java.JSON;

import Torello.Java.StringParse;

import java.lang.reflect.Array;

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

import java.util.Objects;

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



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
        )
    {
        // 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<?>          compClass   = retArrClass.getComponentType();
        final int               SIZE        = ja.size();
        final RETURN_ARR_TYPE   retArr      = (RETURN_ARR_TYPE) Array.newInstance(compClass, 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:

                    Array.set(
                        retArr,
                        i,
                        JSON_ARRAY_DIMN.jsonArrayToJava((JsonArray) jv, rec, compClass)
                    );

                    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;
    }
}