/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.juneau.marshall.json;

import static org.apache.juneau.commons.lang.StateEnum.*;
import static org.apache.juneau.commons.utils.CollectionUtils.*;
import static org.apache.juneau.commons.utils.Shorts.*;
import static org.apache.juneau.commons.utils.StringUtils.*;

import java.io.*;
import java.lang.reflect.*;
import java.util.*;

import org.apache.juneau.commons.bean.*;
import org.apache.juneau.commons.lang.*;
import org.apache.juneau.commons.reflect.*;
import org.apache.juneau.commons.utils.*;
import org.apache.juneau.marshall.*;
import org.apache.juneau.marshall.collections.*;
import org.apache.juneau.marshall.parser.*;
import org.apache.juneau.marshall.stream.*;
import org.apache.juneau.marshall.swap.spi.*;

/**
 * Session object that lives for the duration of a single use of {@link JsonParser}.
 *
 * <h5 class='section'>Notes:</h5><ul>
 *    <li class='warn'>This class is not thread safe and is typically discarded after one use.
 * </ul>
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/JsonSupport">JSON</a>

 * </ul>
 */
@SuppressWarnings({
   "java:S110", // Deep inheritance inherent to the serializer/parser session hierarchy
   "java:S115", // Constants use camelCase intentionally (e.g., decChars)
   "java:S125", // State-machine and parse-path comments (S1: ..., Let o be null) are documentation, not commented-out code
   "java:S135", // readIntoBeanMap2(), readIntoCollection2() and readIntoMap2() use several break/continue guards for invalid characters and separators; restructuring would reduce clarity
   "java:S1168", // readFieldName() returns null for a missing name and doRead() for empty input; the unreachable fall-through returns in readIntoBeanMap2()/readIntoCollection2()/readIntoMap2() also return null
   "java:S1192", // Duplicated literals (argument/property names) read more clearly inline than as constants
   "java:S2583", // State variables persist across loop iterations
   "java:S3776", // readAnything(), readIntoMap2(), readIntoCollection2() and readIntoBeanMap2() are branch-heavy JSON token state machines; splitting them would obscure the grammar
   "java:S6541", // Brain method acceptable for JSON parser dispatch and state machines
   "rawtypes", // Raw types necessary for generic type handling
   "resource", // ParserReader is managed by caller
   "unchecked" // Type erasure requires unchecked casts
})
public class JsonParserSession extends ReaderParserSession implements TokenReadable, ArrayRecordReadable {

   /**
    * Builder class.
    */
   @SuppressWarnings({
      "java:S119" // 'SELF' (CRTP self-type) is intentional and clearer than a single-letter name.
   })
   public abstract static class Builder<SELF extends Builder<SELF>> extends ReaderParserSession.Builder<SELF> {

      private boolean validateEnd;
      private final JsonParser ctx;

      /**
       * Constructor
       *
       * @param ctx The context creating this session.
       */
      protected Builder(JsonParser ctx) {
         super(ctx);
         this.ctx = ctx;
         validateEnd = ctx.isValidateEnd();
      }

      @Override
      public JsonParserSession build() {
         return new JsonParserSession(this);
      }

      /**
       * Validate end.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public SELF validateEnd(boolean value) {
         validateEnd = value;
         return self();
      }

      @Override /* Overridden from Builder */
      public SELF property(String key, Object value) {
         if (key == null) { super.property(key, value); return self(); }
         switch (key) {
            case "validateEnd", "JsonParserSession.validateEnd":
               return validateEnd(cvt(value, Boolean.class));
            default:
               super.property(key, value);
               return self();
         }
      }

   }

   /**
    * Concrete default builder leaf for the non-subclassed {@code create()} path (CRTP terminal).
    */
   public static final class DefaultBuilder extends Builder<DefaultBuilder> {

      DefaultBuilder(JsonParser ctx) {
         super(ctx);
      }
   }

   private static final AsciiSet decChars = AsciiSet.create().ranges("0-9").build();

   /**
    * Creates a new builder for this object.
    *
    * @param ctx The context creating this session.
    * @return A new builder.
    */
   @SuppressWarnings({
      "java:S1452" // Builder<?> wildcard return intentional; callers use it to construct session instances polymorphically
   })
   public static Builder<?> create(JsonParser ctx) {
      return new DefaultBuilder(ctx);
   }

   private final JsonParser ctx;
   private final boolean validateEnd;

   /**
    * Constructor.
    *
    * @param builder The builder for this object.
    */
   protected JsonParserSession(Builder<?> builder) {
      super(builder);
      ctx = builder.ctx;
      validateEnd = builder.validateEnd;
   }

   <T> T readAnything(ClassMeta<?> eType, ParserReader r, Object outer, BeanPropertyMeta pMeta) throws IOException, ParseException, ExecutableException {

      if (eType == null)
         eType = object();
      var swap = (ObjectSwap<T,Object>)eType.getSwap(this);
      var builder = (BuilderSwap<T,Object>)eType.getBuilderSwap(this);
      ClassMeta<?> sType = null;
      if (nn(builder))
         sType = builder.getBuilderClassMeta(this);
      else if (nn(swap))
         sType = swap.getSwapClassMeta(this);
      else
         sType = eType;

      if (sType.isOptional())
         return (T)o(readAnything(eType.getElementType(), r, outer, pMeta));

      setCurrentClass(sType);
      var wrapperAttr = getJsonClassMeta(sType).getWrapperAttr();

      Object o = null;

      skipCommentsAndSpace(r);
      if (nn(wrapperAttr))
         skipWrapperAttrStart(r, wrapperAttr);
      int c = r.peek();
      if (c == -1) {
         onEmptyInput();
      } else if ((c == ',' || c == '}' || c == ']')) {
         onMissingValue();
      } else if (c == 'n') {
         readKeyword("null", r);
      } else if (sType.isObject()) {
         if (c == '{') {
            var m2 = newGenericMap();
            readIntoMap2(r, m2, string(), object(), pMeta);
            o = cast(m2, pMeta, eType);
         } else if (c == '[') {
            o = readIntoCollection2(r, newGenericList(), object(), pMeta);
         } else if (c == '\'' || c == '"') {
            o = readString(r);
            if (sType.isChar())
               o = parseCharacter(o);
         } else if (isNumberStartChar(c)) {
            o = readNumber(r, null);
         } else if (c == 't') {
            readKeyword("true", r);
            o = Boolean.TRUE;
         } else {
            readKeyword("false", r);
            o = Boolean.FALSE;
         }
      } else if (nn(builder)) {
         var m = toBeanMap(builder.create(this, eType));
         o = builder.build(this, checkRequired(readIntoBeanMap2(r, m)).getBean(), eType);
      } else if (sType.canCreateNewBean(outer)) {
         var m = newBeanMap(outer, sType.inner());
         o = checkRequired(readIntoBeanMap2(r, m)).getBean();
      } else if (sType.isMap()) {
         Map m = (sType.canCreateNewInstance(outer) ? (Map)sType.newInstance(outer) : newGenericMap(sType));
         o = readIntoMap2(r, m, sType.getKeyType(), sType.getValueType(), pMeta);
      } else if (sType.isCollection()) {
         if (c == '{') {
            var m = newGenericMap();
            readIntoMap2(r, m, string(), object(), pMeta);
            o = cast(m, pMeta, eType);
         } else {
            Collection l = (sType.canCreateNewInstance(outer) ? (Collection)sType.newInstance() : newGenericList());
            o = readIntoCollection2(r, l, sType, pMeta);
         }
      } else if (sType.isArray() || sType.isArgs()) {
         if (c == '{') {
            var m = newGenericMap();
            readIntoMap2(r, m, string(), object(), pMeta);
            o = cast(m, pMeta, eType);
         } else {
            var l = (ArrayList)readIntoCollection2(r, list(), sType, pMeta);
            o = toArray(sType, l);
         }
      } else if (sType.isCharSequence()) {
         o = readString(r);
      } else if (sType.isChar()) {
         o = parseCharacter(readString(r));
      } else if (sType.isNumber()) {
         o = readNumber(r, (Class<? extends Number>)sType.inner());
      } else if (sType.isBoolean()) {
         o = readBoolean(r);
      } else if (sType.isDate()) {
         o = readDate(readString(r), sType);
      } else if (sType.isCalendar()) {
         o = readCalendar(readString(r), sType);
      } else if (sType.isTemporal()) {
         o = readTemporal(readString(r), sType);
      } else if (sType.isDuration()) {
         o = readDuration(readString(r));
      } else if (sType.isPeriod()) {
         o = readPeriod(readString(r));
      } else if (sType.canCreateNewInstanceFromString(outer) && (c == '\'' || c == '"')) {
         o = sType.newInstanceFromString(outer, readString(r));
      } else if (c == '{') {
         Map m = newGenericMap();
         readIntoMap2(r, m, sType.getKeyType(), sType.getValueType(), pMeta);
         if (m.containsKey(getBeanTypePropertyName(eType)))
            o = cast((MarshalledMap)m, pMeta, eType);
         else if (nn(sType.getProxyInvocationHandler()))
            o = checkRequired(newBeanMap(outer, sType.inner()).load(m)).getBean();
         else
            throw new ParseException(this, "Class '%s' could not be instantiated.  Reason: '%s'", cn(sType), sType.getNotABeanReason());
      } else if (sType.canCreateNewInstanceFromString(outer) && canCoerceNonStringToString()) {
         o = sType.newInstanceFromString(outer, readString(r));
      } else {
         throw new ParseException(this, "Unrecognized syntax for class type '%s', starting character '%s'", sType, (char)c);
      }

      if (nn(wrapperAttr))
         skipWrapperAttrEnd(r);

      if (nn(swap) && nn(o))
         o = unswap(swap, o, eType);

      if (nn(parentBean()))
         setParent(eType, o, parentBean());

      return (T)o;
   }

   private Boolean readBoolean(ParserReader r) throws IOException, ParseException {
      int c = r.peek();
      if (c == '\'' || c == '"')
         return b(readString(r));
      if (c == 't') {
         readKeyword("true", r);
         return Boolean.TRUE;
      } else if (c == 'f') {
         readKeyword("false", r);
         return Boolean.FALSE;
      } else {
         throw new ParseException(this, "Unrecognized syntax.  Expected boolean value, actual='%s'", r.read(100));
      }
   }

   /*
    * Parse a JSON attribute from the character array at the specified position, then
    * set the position marker to the last character in the field name.
    */
   protected String readFieldName(ParserReader r) throws IOException, ParseException {
      int c = r.peek();
      if (c == '\'' || c == '"')
         return readString(r);
      if (c == 'n') {
         readKeyword("null", r);
         return null;
      }
      throw new ParseException(this, "Unquoted attribute detected.");
   }

   private <T> BeanMap<T> readIntoBeanMap2(ParserReader r, BeanMap<T> m) throws IOException, ParseException, ExecutableException {

      // S1: Looking for outer {
      // S2: Looking for attrName start.
      // S3: Found attrName end, looking for :.
      // S4: Found :, looking for valStart: { [ " ' LITERAL.
      // S5: Looking for , or }

      var state = S1;
      var currAttr = "";
      int c = 0;
      var pb = swapParentBean(m.getBean(false));
      mark();
      try {
         while (c != -1) {
            c = r.read();
            if (state == S1) {
               if (c == '{') {
                  state = S2;
               } else if (isCommentOrWhitespace(c)) {
                  skipCommentsAndSpace(r.unread());
               } else {
                  break;
               }
            } else if (state == S2) {
               if (c == '}') {
                  return m;
               } else if (isCommentOrWhitespace(c)) {
                  skipCommentsAndSpace(r.unread());
               } else {
                  r.unread();
                  mark();
                  currAttr = readFieldName(r);
                  state = S3;
               }
            } else if (state == S3) {  // NOSONAR - State check necessary for state machine
               if (c == ':')
                  state = S4;
            } else if (state == S4) {
               if (isCommentOrWhitespace(c)) {
                  skipCommentsAndSpace(r.unread());
               } else {
               if (! currAttr.equals(getBeanTypePropertyName((ClassMeta<?>) m.getBeanInfo()))) {
                  var pMeta = m.getPropertyMeta(currAttr);
                  setCurrentProperty(pMeta);
                  if (pMeta == null) {
                     onUnknownProperty(currAttr, m, readAnything(object(), r.unread(), m.getBean(false), null));
                     unmark();
                  } else {
                     unmark();
                     var cm = (ClassMeta<?>) pMeta.getBeanInfo();
                     Object value = readAnything(cm, r.unread(), m.getBean(false), pMeta);
                     setName(cm, value, currAttr);
                        try {
                           pMeta.set(m, currAttr, value);
                        } catch (BeanRuntimeException e) {
                           onBeanSetterException(pMeta, e);
                           throw e;
                        }
                     }
                     setCurrentProperty(null);
                  }
                  state = S5;
               }
            } else if (state == S5) {
               if (c == ',')
                  state = S2;
               else if (isCommentOrWhitespace(c))
                  skipCommentsAndSpace(r.unread());
               else if (c == '}') {
                  return m;
               }
            }
         }
         if (state == S1)
            throw new ParseException(this, "Expected '{' at beginning of JSON object.");
         else if (state == S3)
            throw new ParseException(this, "Could not find ':' following attribute name on JSON object.");
         else if (state == S5)
            throw new ParseException(this, "Could not find '}' marking end of JSON object.");
      } finally {
         unmark();
         swapParentBean(pb);
      }

      return null; // Unreachable.
   }

   private <E> Collection<E> readIntoCollection2(ParserReader r, Collection<E> l, ClassMeta<?> type, BeanPropertyMeta pMeta) throws IOException, ParseException, ExecutableException {

      // S1: Looking for outermost [
      // S2: Looking for starting [ or { or " or ' or LITERAL or ]
      // S3: Looking for , or ]
      // S4: Looking for starting [ or { or " or ' or LITERAL

      int argIndex = 0;

      var state = S1;
      int c = 0;
      while (c != -1) {
         c = r.read();
         if (state == S1) {
            if (c == '[')
               state = S2;
            else if (isCommentOrWhitespace(c))
               skipCommentsAndSpace(r.unread());
            else
               break;  // Invalid character found.
         } else if (state == S2) {
            if (c == ']') {
               return l;
            } else if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else if (c != -1) {
               l.add((E)readAnything(type.isArgs() ? type.getArg(argIndex++) : type.getElementType(), r.unread(), l, pMeta));
               state = S3;
            }
         } else if (state == S3) {  // NOSONAR - State check necessary for state machine
            if (c == ',') {
               state = S4;
            } else if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else if (c == ']') {
               return l;
            } else {
               break;  // Invalid character found.
            }
         } else if (state == S4) {
            if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else if (c == ']') {
               if (allowsTrailingComma())
                  return l;
               break;
            } else if (c != -1) {
               l.add((E)readAnything(type.isArgs() ? type.getArg(argIndex++) : type.getElementType(), r.unread(), l, pMeta));
               state = S3;
            }
         }
      }
      if (state == S1)
         throw new ParseException(this, "Expected '[' at beginning of JSON array.");
      else if (state == S2)
         throw new ParseException(this, "Expected one of the following characters: {,[,',\",LITERAL.");
      else if (state == S3)
         throw new ParseException(this, "Expected ',' or ']'.");
      else if (state == S4)
         throw new ParseException(this, "Unexpected trailing comma in array.");

      return null;  // Unreachable.
   }

   private <K,V> Map<K,V> readIntoMap2(ParserReader r, Map<K,V> m, ClassMeta<K> keyType, ClassMeta<V> valueType, BeanPropertyMeta pMeta) throws IOException, ParseException, ExecutableException {

      if (keyType == null)
         keyType = (ClassMeta<K>)string();

      // S1: Looking for outer {
      // S2: Looking for attrName start.
      // S3: Found attrName end, looking for :.
      // S4: Found :, looking for valStart: { [ " ' LITERAL.
      // S5: Looking for , or }
      // S6: Found , looking for attr start.

      skipCommentsAndSpace(r);
      var state = S1;
      String currAttr = null;
      int c = 0;
      while (c != -1) {
         c = r.read();
         if (state == S1) {
            if (c == '{')
               state = S2;
            else
               break;
         } else if (state == S2) {
            if (c == '}') {
               return m;
            } else if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else {
               currAttr = readFieldName(r.unread());
               state = S3;
            }
         } else if (state == S3) {  // NOSONAR - State check necessary for state machine
            if (c == ':')
               state = S4;
         } else if (state == S4) {
            if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else {
               K key = convertAttrToType(m, currAttr, keyType);
               V value = readAnything(valueType, r.unread(), m, pMeta);
               setName(valueType, value, key);
               m.put(key, value);
               state = S5;
            }
         } else if (state == S5) {
            if (c == ',') {
               state = S6;
            } else if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else if (c == '}') {
               return m;
            } else {
               break;
            }
         } else if (state == S6) {
            if (c == '}') {
               if (allowsTrailingComma())
                  return m;
               break;
            } else if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else {
               currAttr = readFieldName(r.unread());
               state = S3;
            }
         }
      }
      if (state == S1)
         throw new ParseException(this, "Expected '{' at beginning of JSON object.");
      else if (state == S3)
         throw new ParseException(this, "Could not find ':' following attribute name on JSON object.");
      else if (state == S5)
         throw new ParseException(this, "Could not find '}' marking end of JSON object.");
      else if (state == S6)
         throw new ParseException(this, "Unexpected '}' found in JSON object.");

      return null; // Unreachable.
   }

   /*
    * Looks for the keywords true, false, or null.
    * Throws an exception if any of these keywords are not found at the specified position.
    */
   protected void readKeyword(String keyword, ParserReader r) throws IOException, ParseException {
      String s = r.read(keyword.length());
      if (s.equals(keyword))
         return;
      throw new ParseException(this, "Unrecognized syntax.  Expected='%s', Actual='%s'", keyword, s);
   }

   protected Number readNumber(ParserReader r, Class<? extends Number> type) throws IOException, ParseException {
      int c = r.peek();
      if (c == '\'' || c == '"')
         return readNumber(r, readString(r), type);
      return readNumber(r, r.readNumberString(), type);
   }

   @SuppressWarnings({
      "java:S1172", // r accepted for API consistency; subclasses may use it for position tracking
      "unused" // r accepted for API consistency; subclasses may use it for position tracking
   })
   protected Number readNumber(ParserReader r, String s, Class<? extends Number> type) throws ParseException {

      if (s.isEmpty())
         throw new ParseException(this, "Invalid JSON number: '%s'", s);

      var isNegative = false;
      var c = s.charAt(0);
      if (c == '-') {
         isNegative = true;
         c = (s.length() == 1 ? 'x' : s.charAt(1));
      }

      if (c == '.')
         throw new ParseException(this, "Invalid JSON number: '%s'", s);

      if (c == '0' && s.length() > (isNegative ? 2 : 1)) {
         var c2 = s.charAt((isNegative ? 2 : 1));
         if (c2 != '.' && c2 != 'e' && c2 != 'E')
            throw new ParseException(this, "Invalid JSON number: '%s'", s);
      }

      var i = s.indexOf('.');
      if (i != -1 && (s.length() == (i + 1) || ! decChars.contains(s.charAt(i + 1))))
         throw new ParseException(this, "Invalid JSON number: '%s'", s);

      return StringUtils.parseNumber(s, type);
   }

   /*
    * Starting from the specified position in the character array, returns the
    * position of the character " or '.
    * If the string consists of a concatenation of strings (e.g. 'AAA' + "BBB"), this method
    * will automatically concatenate the strings and return the result.
    */
   protected String readString(ParserReader r) throws IOException, ParseException {
      r.mark();
      int qc = r.read();
      if (qc != '"') {
         var msg = (qc == '\'' ? "Invalid quote character \"%s\" being used." : "Did not find quote character marking beginning of string.  Character=\"%s\"");
         throw new ParseException(this, msg, (char)qc);
      }
      String s = null;
      boolean isInEscape = false;
      int c = 0;
      while (c != -1) {
         c = r.read();
         if (c <= 0x1F)
            throw new ParseException(this, "Unescaped control character encountered: '0x%s'", f("%04X", c));
         if (isInEscape) {
            // @formatter:off
            switch (c) {
               case 'n': r.replace('\n'); break;
               case 'r': r.replace('\r'); break;
               case 't': r.replace('\t'); break;
               case 'f': r.replace('\f'); break;
               case 'b': r.replace('\b'); break;
               case '\\': r.replace('\\'); break;
               case '/': r.replace('/'); break;
               case '\'': r.replace('\''); break;
               case '"': r.replace('"'); break;
               case 'u': {
                  String n = r.read(4);
                  try {
                     r.replace(Integer.parseInt(n, 16), 6);
                  } catch (@SuppressWarnings("unused") NumberFormatException e) {
                     throw new ParseException(this, "Invalid Unicode escape sequence in string.");
                  }
                  break;
               }
               default:
                  throw new ParseException(this, "Invalid escape sequence in string.");
            }
            // @formatter:on
            isInEscape = false;
         } else {
            if (c == '\\') {
               isInEscape = true;
               r.delete();
            } else if (c == qc) {
               s = r.getMarked(1, -1);
               break;
            }
         }
      }
      skipCommentsAndSpace(r);
      if (r.peek() == '+')
         throw new ParseException(this, "String concatenation detected.");
      return trim(s);
   }

   /*
    * Doesn't actually parse anything, but when positioned at the beginning of comment,
    * it will move the pointer to the last character in the comment.
    */
   protected void skipComments(ParserReader r) throws ParseException, IOException {
      int c = r.read();
      if (c == '*') {
         while (c != -1)
            if ((c = r.read()) == '*' && (c = r.read()) == '/')
               return;
      } else if (c == '/') {
         while (c != -1) {
            c = r.read();
            if (c == -1 || c == '\n')
               return;
         }
      }
      throw new ParseException(this, "Open ended comment.");
   }

   protected void skipCommentsAndSpace(ParserReader r) throws IOException, ParseException {
      int c = 0;
      while ((c = r.read()) != -1) {
         if (! isWhitespace(c)) {
            if (c == '/')
               throw new ParseException(this, "Javascript comment detected.");
            r.unread();
            return;
         }
      }
   }

   /*
    * Doesn't actually parse anything, but moves the position beyond the construct "}" when
    * the @Json(wrapperAttr) annotation is used on a class.
    */
   private void skipWrapperAttrEnd(ParserReader r) throws ParseException, IOException {
      int c = 0;
      while ((c = r.read()) != -1) {
         if (! isWhitespace(c)) {
            if (c == '/') {
               throw new ParseException(this, "Javascript comment detected.");
            } else if (c == '}') {
               return;
            } else {
               throw new ParseException(this, "Could not find '}' at the end of JSON wrapper object.");
            }
         }
      }
   }

   /*
    * Doesn't actually parse anything, but moves the position beyond the construct "{wrapperAttr:" when
    * the @Json(wrapperAttr) annotation is used on a class.
    */
   private void skipWrapperAttrStart(ParserReader r, String wrapperAttr) throws IOException, ParseException {

      // S1: Looking for outer '{'
      // S2: Looking for attrName start.
      // S3: Found attrName end, looking for :.
      // S4: Found :, looking for valStart: { [ " ' LITERAL.

      var state = S1;
      String currAttr = null;
      int c = 0;
      while (c != -1) {
         c = r.read();
         if (state == S1) {
            if (c == '{')
               state = S2;
         } else if (state == S2) {
            if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else {
               currAttr = readFieldName(r.unread());
               if (! currAttr.equals(wrapperAttr))
                  throw new ParseException(this, "Expected to find wrapper attribute '%s' but found attribute '%s'", wrapperAttr, currAttr);
               state = S3;
            }
         } else if (state == S3) {  // NOSONAR - State check necessary for state machine
            if (c == ':')
               state = S4;
         } else if (state == S4) {
            if (isCommentOrWhitespace(c)) {
               skipCommentsAndSpace(r.unread());
            } else {
               r.unread();
               return;
            }
         }
      }
      if (state == S1)
         throw new ParseException(this, "Expected '{' at beginning of JSON object.");
      else if (state == S2)
         throw new ParseException(this, "Could not find attribute name on JSON object.");
      else
         throw new ParseException(this, "Could not find ':' following attribute name on JSON object.");
   }

   /*
    * Call this method after you've finished a parsing a string to make sure that if there's any
    * remainder in the input, that it consists only of whitespace and comments.
    */
   private void validateEnd(ParserReader r) throws IOException, ParseException {
      if (! isValidateEnd())
         return;
      skipCommentsAndSpace(r);
      int c = r.read();
      if (c != -1 && c != ';')  // var x = {...}; expressions can end with a semicolon.
         throw new ParseException(this, "Remainder after parse: '%s'.", (char)c);
   }

   @Override /* Overridden from ParserSession */
   protected <T> T doRead(ParserPipe pipe, ClassMeta<T> type) throws IOException, ParseException, ExecutableException {
      try (var r = pipe.getParserReader()) {
         if (r == null)
            return null;
         T o = readAnything(type, r, getOuter(), null);
         validateEnd(r);
         return o;
      }
   }

   /**
    * Opens a low-level pull-parser cursor over a JSON document, bound to this session's live
    * {@link BeanSession}/{@link MarshallingContext}.
    *
    * <p>
    * The cursor is purely structural &mdash; object swaps and {@code @Schema} annotations are not
    * applied at this layer.  See {@link TokenReader} for the contract.
    *
    * <h5 class='section'>Builder properties honored:</h5>
    * The structurally-applicable subset flows through to the cursor: <c>autoCloseStreams</c>,
    * <c>unbuffered</c>, <c>trimStrings</c> (applied to {@link TokenType#VALUE_STRING} and
    * {@link TokenType#FIELD_NAME} values), and the {@code ReaderParser} stream/file charsets.
    *
    * <h5 class='section'>Builder properties NOT honored:</h5>
    * <c>validateEnd()</c> (the cursor leaves end-of-input checking to the caller),
    * <c>listener(...)</c>/<c>debugOutputLines(...)</c>, <c>consumes(...)</c>, object swaps, and
    * {@code @Schema} annotations (only applied on the POJO databind path).
    *
    * @param input The input.  Accepts {@link Reader}, {@link CharSequence}, {@link InputStream},
    *    or <code><jk>byte</jk>[]</code>.
    * @return A new {@link JsonTokenReader}.
    * @throws IOException If a problem occurred opening the underlying input.
    */
   @SuppressWarnings({
      "java:S2095" // ParserPipe lifecycle is transferred to the returned JsonTokenReader, which closes it via its own close(); the caller owns the cursor via try-with-resources.
   })
   @Override /* TokenReadable */
   public TokenReader readTokens(Object input) throws IOException {
      var pipe = new ParserPipe(
         input,
         isDebug(),
         false /* strict */,
         isAutoCloseStreams(),
         isUnbuffered(),
         getStreamCharset());
      return new JsonTokenReader(pipe, new JsonTokenReader.Settings(isTrimStrings()), this);
   }

   /**
    * Streaming array-element {@link RecordReader} backed by {@link JsonTokenReader}.
    * Memory is O(1) in the array length &mdash; elements are bound on demand using this live session.
    *
    * @param input The input.
    * @return A new element-streamed {@link RecordReader}.
    * @throws IOException If a problem occurred opening the underlying input.
    */
   @Override /* ArrayRecordReadable */
   public RecordReader readArrayRecords(Object input) throws IOException {
      try {
         return StreamingArrayRecord.reader(readTokens(input));
      } catch (ParseException e) {
         throw new IOException(e);
      }
   }

   @Override /* Overridden from ReaderParserSession */
   protected <E> Collection<E> doReadIntoCollection(ParserPipe pipe, Collection<E> c, Type elementType) throws IOException, ParseException, ExecutableException {
      try (var r = pipe.getParserReader()) {
         c = readIntoCollection2(r, c, getClassMeta(elementType == null ? Object.class : elementType), null);
         validateEnd(r);
         return c;
      }
   }

   @Override /* Overridden from ReaderParserSession */
   protected <K,V> Map<K,V> doReadIntoMap(ParserPipe pipe, Map<K,V> m, Type keyType, Type valueType) throws IOException, ParseException, ExecutableException {
      try (var r = pipe.getParserReader()) {
         m = readIntoMap2(r, m, (ClassMeta<K>)getClassMeta(keyType == null ? Object.class : keyType), (ClassMeta<V>)getClassMeta(valueType == null ? Object.class : valueType), null);
         validateEnd(r);
         return m;
      }
   }

   /**
    * Returns the language-specific metadata on the specified class.
    *
    * @param cm The class to return the metadata on.
    * @return The metadata.
    */
   protected JsonClassMeta getJsonClassMeta(ClassMeta<?> cm) {
      return ctx.getJsonClassMeta(cm);
   }

   /**
    * Returns <jk>true</jk> if the specified character can start a number value.
    *
    * <p>
    * JSON numbers start with a digit, <c>-</c>, or <c>.</c>.  JSON5 subclasses also accept
    * <c>+</c>, <c>I</c> (<c>Infinity</c>), and <c>N</c> (<c>NaN</c>).
    *
    * @param c The next non-whitespace character.
    * @return <jk>true</jk> if a number lexeme should be read from this character.
    */
   protected boolean isNumberStartChar(int c) {
      return (c >= '0' && c <= '9') || c == '-' || c == '.';
   }

   /**
    * Returns <jk>true</jk> if the specified character is whitespace or '/'.
    *
    * @param cp The codepoint.
    * @return <jk>true</jk> if the specified character is whitespace or '/'.
    */
   protected boolean isCommentOrWhitespace(int cp) {
      if (cp == '/')
         return true;
      return cp <= 0x20 && (cp == 0x09 || cp == 0x0A || cp == 0x0D || cp == 0x20);
   }

   /**
    * Validate end.
    *
    * @see JsonParser.Builder#validateEnd()
    * @return
    *    <jk>true</jk> if after parsing a POJO from the input, verifies that the remaining input in
    *    the stream consists of only comments or whitespace.
    */
   protected boolean isValidateEnd() { return validateEnd; }

   /**
    * Returns <jk>true</jk> if the specified character is whitespace.
    *
    * <p>
    * Only 0x20 (space), 0x09 (tab), 0x0A (line feed) and 0x0D (carriage return) are considered whitespace.
    *
    * @param cp The codepoint.
    * @return <jk>true</jk> if the specified character is whitespace.
    */
   protected boolean isWhitespace(int cp) {
      return cp <= 0x20 && (cp == 0x09 || cp == 0x0A || cp == 0x0D || cp == 0x20);
   }

   /**
    * Hook called when empty input is detected in {@code readAnything()}.
    *
    * @throws ParseException Always in strict mode.
    */
   protected void onEmptyInput() throws ParseException {
      throw new ParseException(this, "Empty input.");
   }

   /**
    * Hook called when a missing value is detected in {@code readAnything()}.
    *
    * @throws ParseException Always in strict mode.
    */
   protected void onMissingValue() throws ParseException {
      throw new ParseException(this, "Missing value detected.");
   }

   /**
    * Returns whether trailing commas are accepted before <c>]</c> / <c>}</c> in the databind path.
    *
    * <p>
    * Default returns <jk>false</jk> (strict RFC-8259 JSON).  {@code Json5ParserSession} overrides
    * this to <jk>true</jk> for the JSON5 dialect.
    *
    * @return <jk>true</jk> if a trailing comma should be silently accepted.
    */
   protected boolean allowsTrailingComma() {
      return false;
   }

   /**
    * Returns whether non-string types can be coerced to strings using {@code newInstanceFromString()}.
    *
    * @return Always {@code false} for standard JSON.
    */
   protected boolean canCoerceNonStringToString() {
      return false;
   }

   @Override /* Overridden from MarshallingSession */
   protected MarshalledMap newGenericMap() {
      return new JsonMap(this);
   }

   @Override /* Overridden from MarshallingSession */
   protected MarshalledList newGenericList() {
      return new JsonList(this);
   }
}