package Torello.Browser.BrowserAPI.NestedHelpers.Types;

import static Torello.Browser.CDPTypes.*;

import Torello.JSON.*;
import Torello.Java.ReadOnly.*;
import Torello.Browser.*;
import Torello.Browser.BrowserAPI.*;
import Torello.Browser.JavaScriptAPI.*;
import Torello.Browser.helper.*;

import javax.json.JsonObject;
import javax.json.stream.JsonGenerator;

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

import java.util.stream.IntStream;


public class Accessibility$$AXNode$$
    implements NestedHelper<Accessibility.AXNode>
{
    // ********************************************************************************************
    // ********************************************************************************************
    // Constructor, Singleton & "Reflection"
    // ********************************************************************************************
    // ********************************************************************************************


    // Simple Constructor, used *ONLY* to construct the singleton instance, directly below
    private Accessibility$$AXNode$$() { }

    // Single Instance of this class.  How all the instance methods are invoked, statically
    public static final Accessibility$$AXNode$$ singleton = new Accessibility$$AXNode$$();

    // Pointer / Reference to the Domain's Nested-Class which is being 'helped' by this class.
    public static final Class<Accessibility.AXNode> baseTypeClass =
        Accessibility.AXNode.class;

    // Stores simple Reflection Information about Accessibility.AXNode
    public static final NestedDescriptor<Accessibility.AXNode> descriptor;

    static
    {
        // The names of each field in this helper class
        final ReadOnlyList<String> names = new ReadOnlyArrayList<>(
            String.class, "nodeId", "ignored", "ignoredReasons", "role", "chromeRole", "name",
            "description", "value", "properties", "parentId", "childIds", "backendDOMNodeId",
            "frameId"
        );

        // Type of each field, stored using the constants in Torello.Browser.CDPTypes
        final ReadOnlyList<Byte> types = new ReadOnlyArrayList<>(
            Byte.class, STRING, PRIMITIVE_BOOLEAN, CDP_TYPE_ARRAY_1D, CDP_TYPE, CDP_TYPE, CDP_TYPE,
            CDP_TYPE, CDP_TYPE, CDP_TYPE_ARRAY_1D, STRING, STRING_ARRAY_1D, BOXED_INTEGER, STRING
        );

        // Whether each field is optional or not, as defined in Google's CDP Specs
        final ReadOnlyList<Boolean> optionals = new ReadOnlyArrayList<>(
            Boolean.class, false, false, true, true, true, true, true, true, true, true, true, true,
            true
        );

        // Whether each field is experimental or not, as defined in Google's CDP Specs
        final ReadOnlyList<Boolean> experimentals = new ReadOnlyArrayList<>(
            Boolean.class, false, false, false, false, false, false, false, false, false, false,
            false, false, false
        );

        descriptor = new NestedDescriptor<>(
            Domains.Accessibility, "AXNode", names, types, optionals, experimentals, baseTypeClass
        );
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Simple Getters & Helpers
    // ********************************************************************************************
    // ********************************************************************************************


    // Can be used to generate an instance using the advanced 'TypeBuilder' class
    public NestedDescriptor<Accessibility.AXNode> descriptor()
    { return descriptor; }

    // Build the 'isPresent' read-only list using the class' current assigned values
    public ReadOnlyList<Boolean> generateIsPresentList(final Accessibility.AXNode THIS)
    {
        return new ReadOnlyArrayList<>(
            Boolean.class,
            THIS.nodeId             == null,
            THIS.ignored            == DV.NULL_BOOL,
            THIS.ignoredReasons     == null,
            THIS.role               == null,
            THIS.chromeRole         == null,
            THIS.name               == null,
            THIS.description        == null,
            THIS.value              == null,
            THIS.properties         == null,
            THIS.parentId           == null,
            THIS.childIds           == null,
            THIS.backendDOMNodeId   == null,
            THIS.frameId            == null
        );
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // java.lang.Object Methods
    // ********************************************************************************************
    // ********************************************************************************************


    // Checks whether 'THIS' equals an input Java-Object
    public boolean equals(final Accessibility.AXNode THIS, final Object OTHER)
    {
        if (THIS == OTHER) return true;
        if (OTHER == null) return false;

        // This equals expects that the instance be of the exact class
        if (OTHER.getClass() != Accessibility.AXNode.class) return false;

        final Accessibility.AXNode O = (Accessibility.AXNode) OTHER;

        return
                Objects.equals(THIS.nodeId, O.nodeId)
            &&  (THIS.ignored == O.ignored)
            &&  Arrays.equals(THIS.ignoredReasons, O.ignoredReasons)
            &&  Objects.equals(THIS.role, O.role)
            &&  Objects.equals(THIS.chromeRole, O.chromeRole)
            &&  Objects.equals(THIS.name, O.name)
            &&  Objects.equals(THIS.description, O.description)
            &&  Objects.equals(THIS.value, O.value)
            &&  Arrays.equals(THIS.properties, O.properties)
            &&  Objects.equals(THIS.parentId, O.parentId)
            &&  Arrays.equals(THIS.childIds, O.childIds)
            &&  Objects.equals(THIS.backendDOMNodeId, O.backendDOMNodeId)
            &&  Objects.equals(THIS.frameId, O.frameId);
    }

    // Generates a Hash-Code for 'THIS' instance
    public int hashCode(final Accessibility.AXNode THIS)
    {
        return
                ((THIS.nodeId == null) ? 0 : THIS.nodeId.hashCode())
            +   (THIS.ignored ? 1 : 0)
            +   ((THIS.ignoredReasons == null) ? 0 : Arrays.deepHashCode(THIS.ignoredReasons))
            +   Objects.hashCode(THIS.role)
            +   Objects.hashCode(THIS.chromeRole)
            +   Objects.hashCode(THIS.name)
            +   Objects.hashCode(THIS.description)
            +   Objects.hashCode(THIS.value)
            +   ((THIS.properties == null) ? 0 : Arrays.deepHashCode(THIS.properties))
            +   ((THIS.parentId == null) ? 0 : THIS.parentId.hashCode())
            +   ((THIS.childIds == null) ? 0 : Arrays.hashCode(THIS.childIds))
            +   ((THIS.backendDOMNodeId == null) ? 0 : THIS.backendDOMNodeId.intValue())
            +   ((THIS.frameId == null) ? 0 : THIS.frameId.hashCode());
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Json Methods
    // ********************************************************************************************
    // ********************************************************************************************


    // Converts this instance to JSON
    public void toJSON(
            final Accessibility.AXNode  THIS,
            final String                name,
            final JsonGenerator         jGen
        )
    {
        final ReadOnlyList<Boolean> isPresent = THIS.isPresent();

        if (name != null)   jGen.writeStartObject(name);
        else                jGen.writeStartObject();

        if (isPresent.get(0))
        {
            // Writing Type: String (CDPTypes.STRING), *IS NOT* optional
            if (THIS.nodeId == null)    jGen.writeNull();
            else                        jGen.write("nodeId", THIS.nodeId);
        }

        if (isPresent.get(1))
        {
            // Writing Type: boolean (CDPTypes.PRIMITIVE_BOOLEAN), *IS NOT* optional
            jGen.write("ignored", THIS.ignored);
        }

        if (isPresent.get(2))
        {
            // Writing Type: Accessibility.AXProperty[] (CDPTypes.CDP_TYPE_ARRAY_1D), *IS* optional
            if (THIS.ignoredReasons == null) jGen.writeNull();
            else
            {
                jGen.writeStartArray("ignoredReasons");
                for (final BaseType<?> baseType : THIS.ignoredReasons)
                    if (baseType == null)   jGen.writeNull();
                    else                    baseType.toJSON(null, jGen);
                jGen.writeEnd();
            }
        }

        if (isPresent.get(3))
        {
            // Writing Type: Accessibility.AXValue (CDPTypes.CDP_TYPE), *IS* optional
            if (THIS.role == null)  jGen.writeNull();
            else                    THIS.role.toJSON("role", jGen);
        }

        if (isPresent.get(4))
        {
            // Writing Type: Accessibility.AXValue (CDPTypes.CDP_TYPE), *IS* optional
            if (THIS.chromeRole == null)    jGen.writeNull();
            else                            THIS.chromeRole.toJSON("chromeRole", jGen);
        }

        if (isPresent.get(5))
        {
            // Writing Type: Accessibility.AXValue (CDPTypes.CDP_TYPE), *IS* optional
            if (THIS.name == null)  jGen.writeNull();
            else                    THIS.name.toJSON("name", jGen);
        }

        if (isPresent.get(6))
        {
            // Writing Type: Accessibility.AXValue (CDPTypes.CDP_TYPE), *IS* optional
            if (THIS.description == null)   jGen.writeNull();
            else                            THIS.description.toJSON("description", jGen);
        }

        if (isPresent.get(7))
        {
            // Writing Type: Accessibility.AXValue (CDPTypes.CDP_TYPE), *IS* optional
            if (THIS.value == null) jGen.writeNull();
            else                    THIS.value.toJSON("value", jGen);
        }

        if (isPresent.get(8))
        {
            // Writing Type: Accessibility.AXProperty[] (CDPTypes.CDP_TYPE_ARRAY_1D), *IS* optional
            if (THIS.properties == null) jGen.writeNull();
            else
            {
                jGen.writeStartArray("properties");
                for (final BaseType<?> baseType : THIS.properties)
                    if (baseType == null)   jGen.writeNull();
                    else                    baseType.toJSON(null, jGen);
                jGen.writeEnd();
            }
        }

        if (isPresent.get(9))
        {
            // Writing Type: String (CDPTypes.STRING), *IS* optional
            if (THIS.parentId == null)  jGen.writeNull();
            else                        jGen.write("parentId", THIS.parentId);
        }

        if (isPresent.get(10))
        {
            // Writing Type: String[] (CDPTypes.STRING_ARRAY_1D), *IS* optional
            if (THIS.childIds == null) jGen.writeNull();
            else
            {
                jGen.writeStartArray("childIds");
                for (final String s : THIS.childIds)
                    if (s == null)  jGen.writeNull();
                    else            jGen.write(s);
                jGen.writeEnd();
            }
        }

        if (isPresent.get(11))
        {
            // Writing Type: Integer (CDPTypes.BOXED_INTEGER), *IS* optional
            if (THIS.backendDOMNodeId == null)  jGen.writeNull();
            else                                jGen.write("backendDOMNodeId", THIS.backendDOMNodeId.intValue());
        }

        if (isPresent.get(12))
        {
            // Writing Type: String (CDPTypes.STRING), *IS* optional
            if (THIS.frameId == null)   jGen.writeNull();
            else                        jGen.write("frameId", THIS.frameId);
        }
    }

    // Generates an instance of this class, using a JsonObject as input
    public Accessibility.AXNode fromJSON(final JsonObject jo)
    {
        final ReadOnlyList<Boolean> isPresent = new ReadOnlyArrayList<>(
            Boolean.class,
            jo.containsKey("nodeId"),
            jo.containsKey("ignored"),
            jo.containsKey("ignoredReasons"),
            jo.containsKey("role"),
            jo.containsKey("chromeRole"),
            jo.containsKey("name"),
            jo.containsKey("description"),
            jo.containsKey("value"),
            jo.containsKey("properties"),
            jo.containsKey("parentId"),
            jo.containsKey("childIds"),
            jo.containsKey("backendDOMNodeId"),
            jo.containsKey("frameId")
        );

        return new Accessibility.AXNode(
            isPresent,
            ReadJSON.getString(jo, "nodeId", true, false),
            ReadBoxedJSON.getBoolean(jo, "ignored", JFlag.RD_N | JFlag.RD_M, DV.NULL_BOOL),
            (isPresent.get(2) == false)
                ? null
                : RJArrIntoStream
                    .objArr(
                        jo.getJsonArray("ignoredReasons"), null, 0,
                        Accessibility.AXProperty::fromJSON,
                        Accessibility.AXProperty.class
                    )
                    .toArray(Accessibility.AXProperty[]::new),
            ReadJSON.getObject(
                jo, "role",
                Accessibility.AXValue::fromJSON,
                Accessibility.AXValue.class,
                true, false
            ),
            ReadJSON.getObject(
                jo, "chromeRole",
                Accessibility.AXValue::fromJSON,
                Accessibility.AXValue.class,
                true, false
            ),
            ReadJSON.getObject(
                jo, "name",
                Accessibility.AXValue::fromJSON,
                Accessibility.AXValue.class,
                true, false
            ),
            ReadJSON.getObject(
                jo, "description",
                Accessibility.AXValue::fromJSON,
                Accessibility.AXValue.class,
                true, false
            ),
            ReadJSON.getObject(
                jo, "value",
                Accessibility.AXValue::fromJSON,
                Accessibility.AXValue.class,
                true, false
            ),
            (isPresent.get(8) == false)
                ? null
                : RJArrIntoStream
                    .objArr(
                        jo.getJsonArray("properties"), null, 0,
                        Accessibility.AXProperty::fromJSON,
                        Accessibility.AXProperty.class
                    )
                    .toArray(Accessibility.AXProperty[]::new),
            ReadJSON.getString(jo, "parentId", true, false),
            (isPresent.get(10) == false)
                ? null
                : RJArrIntoStream
                    .strArr(jo.getJsonArray("childIds"), null, 0)
                    .toArray(String[]::new),
            ReadBoxedJSON.getInteger(jo, "backendDOMNodeId", true),
            ReadJSON.getString(jo, "frameId", true, false)
        );
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Enumerated String Constant Fields' Issues
    // ********************************************************************************************
    // ********************************************************************************************


    // None of the fields inside this class are of an enumerated string type
    private static final ReadOnlyMap<String, ReadOnlyList<String>> allEnumStrs =
        ReadOnlyTreeMap.emptyROTM();

    // Utilized by abstract ancestor 'BaseType'
    public ReadOnlyMap<String, ReadOnlyList<String>> allEnumStrROLs()
    { return allEnumStrs; }

    // None of the fields inside this class have an enumerated string type
    public IntStream enumStrValidate(final Accessibility.AXNode THIS)
    { return IntStream.empty(); }
}