package Torello.JSON;

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

import javax.json.JsonString;
import javax.json.JsonValue;

import static javax.json.JsonValue.ValueType.NUMBER;
import static javax.json.JsonValue.ValueType.STRING;

import static Torello.JSON.JFlag.*;

// An (extremely) temporary class.  This is created in the SettingsRec Constructor, and then it is
// GC'ed as soon as that Constructor finishes.
// 
// IMPORTANT NOTE: These booleans are used to decide WHICH Lambda to return.  These boolean's 
//                 ARE NEVER used inside of a Lambda - which (if you try really had to think about 
//                 it) means the GC will not retain or keep these once the SettingsRec Constructor
//                 has finished.
// 
// 
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// The 'ja' instance declared in class "SettingsRec" **IS NOT** declared final.  It can be reset !
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// 
// IMPORTANT NOTE: The 'ja' that is passed to the Functional-Interface Implementatons which are 
// constructed in this method is "de-referenced" from the SettingsRec -- It **IS NOT** passed as
// a parameter to this method.  If it **WERE NOT** retrieved from the 'SettingsRec', then 'sr'
// instance, then the 'ja' that would be used would be permanently-solidified to the 'ja' 
// referenced that were passed right at the beginning, upon construction of the SettingsRec
// instance.

public class FlagsToHandler<T>
{
    // Internally used flags.  These are actually only used during the construction phase, and 
    // therefore these don't have to be "instance fields" at all, they could easily just be final
    // variables that are used (and then discarded) inside of the constructor only.  However, since
    // there has been a recent "Breaking up the Monolithic Constructor" into smaller pieces, these
    // were moved here.
    // 
    // These could also, EASILY, be final-variables that are passed as parameters into the methods 
    // that use them, but this seems OK.  The garbage collector really won't know the difference,
    // because these are primitives.

    private final boolean NULLS, RN_AA, RD_AA, S_AA;

    // Some of the FLAGS.
    private final boolean RTS_WT, RJA_AEX, IN_NSAT, S_NSAT;

    // A Quick Getter for three of the above private fields
    boolean RJA_AEX()   { return this.RJA_AEX;  }
    boolean IN_NSAT()   { return this.IN_NSAT;  }
    boolean S_NSAT()    { return this.S_NSAT;   }

    // Save the actual-complete FLAGS Mask
    private final int FLAGS;

    private final ACCEPTOR<T> acceptor;

    FlagsToHandler(
            final int           FLAGS,
            final boolean       NULLS,
            final ACCEPTOR<T>   acceptor
        )
    {
        this.RJA_AEX    = (FLAGS & RETURN_JAPPROX_ON_AEX) > 0;
        this.RTS_WT     = (FLAGS & RETURN_TOSTRING_ON_WRONGTYPE) > 0;
        this.IN_NSAT    = (FLAGS & INSERT_NULL_ON_NON_SUBARRAY_TYPE) > 0;
        this.S_NSAT     = (FLAGS & SKIP_ON_NON_SUBARRAY_TYPE) > 0;


        // Fields which are (only) used in the "Handler Selector Methods" below
        // These could be converted into Final-Variables that are passed as parameters into the
        // Selector-Methods below, but I chose not too.  I don't have a good reason.  The way it is
        // being done, now, is a tiny bit wasteful since they are now saved as Final / Constant
        // Fields in this class, but they are private and aren't ever used after this constructor
        // finishes!
        // 
        // Passing them as a long list of parameters to each of the selector methods would also be
        // a "Tiny Bit" slower!

        this.NULLS = NULLS;
        this.RN_AA = NULLS && ((FLAGS & RETURN_NULL_ON_ANY_ALL) > 0);
        this.RD_AA = (FLAGS & RETURN_DEFVAL_ON_ANY_ALL) > 0;
        this.S_AA  = (FLAGS & SKIP_ON_ANY_ALL) > 0;

        this.FLAGS      = FLAGS;
        this.acceptor   = acceptor;
    }


    // Used when Json-Null is encountered in a Json-Array
    IntConsumer selectNullHandler(final SettingsRec<?, ?> sr)
    {
        if (NULLS && ((FLAGS & RETURN_NULL_ON_NULL) > 0))   return acceptor::AN;
        else if ((FLAGS & RETURN_DEFVAL_ON_NULL) > 0)       return this.acceptor::AD;
        else if ((FLAGS & SKIP_ON_NULL) > 0)                return this.acceptor::NOOP;
        else if (NULLS && RN_AA)                            return this.acceptor::AN;
        else if (RD_AA)                                     return this.acceptor::AD;
        else if (S_AA)                                      return this.acceptor::NOOP;
        else if (NULLS)                                     return this.acceptor::AN;


        // IMPORTANT NOTE: See the comment at the top of this class regarding the 'sr.ja'
        // versus 'ja' (being passed as a parameter to this method).

        else return (int i) ->
            { throw new JsonNullPrimitiveArrException(sr.ja, i, NUMBER, sr.CLASS); };
    }

    // AEX Handler (ArithmeticException)
    IntConsumer selectAEXHandler()
    {
        if (NULLS && ((FLAGS & RETURN_NULL_ON_AEX) > 0))    return this.acceptor::AN;
        else if ((FLAGS & RETURN_DEFVAL_ON_AEX) > 0)        return this.acceptor::AD;
        else if ((FLAGS & SKIP_ON_AEX) > 0)                 return this.acceptor::NOOP;
        else if (NULLS && RN_AA)                            return this.acceptor::AN;
        else if (RD_AA)                                     return this.acceptor::AD;
        else if (S_AA)                                      return this.acceptor::NOOP;

        return null;
    }

    // SPEX Handler (Exception while parsing a String into the Java-Type)
    private IntConsumer selectSPEXHandler()
    {
        if (NULLS && ((FLAGS & RETURN_NULL_ON_SPEX) > 0))   return this.acceptor::AN;
        else if ((FLAGS & RETURN_DEFVAL_ON_SPEX) > 0)       return this.acceptor::AD;
        else if ((FLAGS & SKIP_ON_SPEX) > 0)                return this.acceptor::NOOP;
        else if (NULLS && RN_AA)                            return this.acceptor::AN;
        else if (RD_AA)                                     return this.acceptor::AD;
        else if (S_AA)                                      return this.acceptor::NOOP;

        return null;
    }

    // ZLS Handler (A Zero-Length String was in the JsonArray)
    private IntConsumer selectZLSHandler()
    {
        if (NULLS && ((FLAGS & RETURN_NULL_ON_0LEN_STR) > 0))   return this.acceptor::AN;
        else if ((FLAGS & RETURN_DEFVAL_ON_0LEN_STR) > 0)       return this.acceptor::AD;
        else if ((FLAGS & SKIP_ON_0LEN_STR) > 0)                return this.acceptor::NOOP;
        else if (NULLS && RN_AA)                                return this.acceptor::AN;
        else if (RD_AA)                                         return this.acceptor::AD;
        else if (S_AA)                                          return this.acceptor::NOOP;

        return null;
    }

    // Wrong-Type Handler (A JsonObject or a nested-JsonArray was in an array position)
    IntConsumer selectWrongTypeHandler()
    {
        if (NULLS && ((FLAGS & RN_WT) > 0))             return this.acceptor::AN;
        else if ((FLAGS & RD_WT) > 0)                   return this.acceptor::AD;
        else if ((FLAGS & SKIP_ON_WRONG_JSONTYPE) > 0)  return this.acceptor::NOOP;
        else if (NULLS && RN_AA)                        return this.acceptor::AN;
        else if (RD_AA)                                 return this.acceptor::AD;
        else if (S_AA)                                  return this.acceptor::NOOP;

        return null;
    }


    // JsonString Handler: **ONLY USED BY** ProcessJsonArray.numericToJava
    <T> ObjIntConsumer<JsonString> selectJsonStringHandler(
            final SettingsRec<T, ?>     sr,
            final Function<String, T>   userParser,

            // BASIC_TYPES: bt.whichType,
            final byte whichType,

            // BASIC_TYPES: bt.validStrTester,
            final Predicate<String> validStrTester,

            // BASIC_TYPES: bt.defaultParser
            final Function<String, T> defaultParser
        )
    {
        final IntConsumer handlerSPEX  = this.selectSPEXHandler();
        final IntConsumer handlerZLS   = this.selectZLSHandler();

        if (userParser != null)
            return ChooseStringHandler.useUserParser
                (sr, sr.CLASS, sr.acceptor, userParser, handlerSPEX);

        else if ((FLAGS & RP_S) > 0) return (whichType == BASIC_TYPES.NUMBER)

            ? ChooseStringHandler.parseStringNUMBER
                (sr, sr.CLASS, sr.acceptor, handlerSPEX, handlerZLS)

            : ChooseStringHandler.parseString(
                sr, sr.CLASS, sr.acceptor,
                handlerSPEX, handlerZLS, validStrTester, defaultParser
            );

        else if (NULLS && ((FLAGS & RETURN_NULL_ON_STR) > 0))   return this.acceptor::AN;
        else if ((FLAGS & RETURN_DEFVAL_ON_STR) > 0)            return this.acceptor::AD;
        else if ((FLAGS & SKIP_ON_STR) > 0)                     return this.acceptor::NOOP;
        else if (NULLS && RN_AA)                                return this.acceptor::AN;
        else if (RD_AA)                                         return this.acceptor::AD;
        else if (S_AA)                                          return this.acceptor::NOOP;

        // Thanksgiving 2024
        else if (sr.handlerWrongType != null)
            return (JsonString js, int i) -> sr.handlerWrongType.accept(i);


        // IMPORTANT NOTE: See the comment at the top of this class regarding the 'sr.ja'
        // versus 'ja' (being passed as a parameter to this method).

        else return (JsonString js, int i) ->
            { throw new JsonTypeArrException (sr.ja, i, NUMBER, js, sr.CLASS); };
    }

    <T> ObjIntConsumer<JsonValue> selectJsonStringWrongTypeHandler
        (final SettingsRec<String, ?> sr)
    {
        if (this.RTS_WT)
            return (JsonValue jv, int i) -> sr.acceptor.accept(jv.toString(), i);

        else if (sr.handlerWrongType != null)
            return (JsonValue jv, int i) -> sr.handlerWrongType.accept(i);


        // IMPORTANT NOTE: See the comment at the top of this class regarding the 'sr.ja'
        // versus 'ja' (being passed as a parameter to this method).

        else return (JsonValue jv, int i) ->
            { throw new JsonTypeArrException(sr.ja, i, STRING, jv, String.class); };
    }
}