/*
 * 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.utils.StringUtils.*;

import java.io.*;

import org.apache.juneau.commons.collections.*;
import org.apache.juneau.commons.lang.*;
import org.apache.juneau.marshall.*;
import org.apache.juneau.marshall.serializer.*;

/**
 * Specialized writer for serializing JSON.
 *
 * <h5 class='section'>Notes:</h5><ul>
 *    <li class='note'>
 *       This class is not intended for external 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:S107", // The constructor and create() take the writer plus all formatting flags, mirroring the serializer settings.
   "java:S119", // 'SELF' (CRTP self-type) is intentional and clearer than a single-letter name.
   "java:S3776", // attr() and stringValue() need nested character-class and escape branching to decide quoting in one pass.
   "resource" // Writer resource managed by calling code
})
public abstract class JsonWriter<SELF extends JsonWriter<SELF>> extends SerializerWriter<SELF> {

   // Characters that trigger special handling of serializing attribute values.
   // @formatter:off
   // Includes all C0 control characters (U+0000-U+001F) and DEL (U+007F), which must be escaped per RFC 8259.
   private static final AsciiSet encodedChars = AsciiSet.create().range('\u0000', '\u001f').chars("\u007f'\"\\").build();
   private static final AsciiSet encodedChars2 = AsciiSet.create().range('\u0000', '\u001f').chars("\u007f'\"\\/").build();

   private static final char[] HEX = "0123456789abcdef".toCharArray();

   private static final KeywordSet reservedWords = new KeywordSet(
      "arguments","break","case","catch","class","const","continue","debugger","default","delete",
      "do","else","enum","eval","export","extends","false","finally","for","function","if",
      "implements","import","in","instanceof","interface","let","new","null","package",
      "private","protected","public","return","static","super","switch","this","throw",
      "true","try","typeof","var","void","while","with","undefined","yield"
   );
   // @formatter:on

   // Characters that represent attribute name characters that don't trigger quoting.
   // These are actually more strict than the actual Javascript specification, but
   // can be narrowed in the future if necessary.
   // For example, we quote attributes that start with $ even though we don't need to.
   private static final AsciiSet validAttrChars = AsciiSet.create().ranges("a-z", "A-Z", "0-9").chars("_").build();

   private static final AsciiSet validFirstAttrChars = AsciiSet.create().ranges("a-z", "A-Z").chars("_").build();
   private final boolean simpleAttrs;
   private final boolean escapeSolidus;

   private final AsciiSet ec;

   /**
    * Constructor.
    *
    * @param out The writer being wrapped.
    * @param useWhitespace If <jk>true</jk>, tabs and spaces will be used in output.
    * @param maxIndent The maximum indentation level.
    * @param escapeSolidus If <jk>true</jk>, forward slashes should be escaped in the output.
    * @param quoteChar The quote character to use (i.e. <js>'\''</js> or <js>'"'</js>)
    * @param simpleAttrs If <jk>true</jk>, JSON attributes will only be quoted when necessary.
    * @param trimStrings If <jk>true</jk>, strings will be trimmed before being serialized.
    * @param uriResolver The URI resolver for resolving URIs to absolute or root-relative form.
    */
   protected JsonWriter(Writer out, boolean useWhitespace, int maxIndent, boolean escapeSolidus, char quoteChar, boolean simpleAttrs, boolean trimStrings, UriResolver uriResolver) {
      super(out, useWhitespace, maxIndent, trimStrings, quoteChar, uriResolver);
      this.simpleAttrs = simpleAttrs;
      this.escapeSolidus = escapeSolidus;
      this.ec = escapeSolidus ? encodedChars2 : encodedChars;
   }

   /**
    * Creates a new JsonWriter instance.
    * <p>
    * Provided for subclasses in other packages (e.g. Json5SerializerSession) that need to create JsonWriter instances.
    *
    * @param out The writer being wrapped.
    * @param useWhitespace If <jk>true</jk>, tabs and spaces will be used in output.
    * @param maxIndent The maximum indentation level.
    * @param escapeSolidus If <jk>true</jk>, forward slashes should be escaped in the output.
    * @param quoteChar The quote character to use (i.e. <js>'\''</js> or <js>'"'</js>)
    * @param simpleAttrs If <jk>true</jk>, JSON attributes will only be quoted when necessary.
    * @param trimStrings If <jk>true</jk>, strings will be trimmed before being serialized.
    * @param uriResolver The URI resolver for resolving URIs to absolute or root-relative form.
    * @return A new JsonWriter instance.
    */
   public static BasicJsonWriter create(Writer out, boolean useWhitespace, int maxIndent, boolean escapeSolidus, char quoteChar, boolean simpleAttrs, boolean trimStrings, UriResolver uriResolver) {
      return new BasicJsonWriter(out, useWhitespace, maxIndent, escapeSolidus, quoteChar, simpleAttrs, trimStrings, uriResolver);
   }

   /**
    * Serializes the specified object as a JSON attribute name.
    *
    * @param s The object being serialized.
    *    <br>Can be <jk>null</jk> (emitted as the literal <js>"null"</js>).
    * @return This object.
    */
   public SELF attr(String s) {

      if (trimStrings)
         s = trim(s);

      /*
       * Converts a Java string to an acceptable JSON attribute name. If
       * simpleAttrs is true, then quotes will only be used if the attribute
       * name consists of only alphanumeric characters.
       */
      boolean doConvert = ! simpleAttrs;     // Always convert when not in lax mode.

      if (s == null) {
         s = "null";
         doConvert = false;

      } else {

         // Look for characters that would require the attribute to be quoted.
         // All possible numbers should be caught here.
         if (! doConvert) {
            for (var i = 0; i < s.length() && ! doConvert; i++) {
               var c = s.charAt(i);
               doConvert |= ! (i == 0 ? validFirstAttrChars.contains(c) : validAttrChars.contains(c));
            }
         }

         // Reserved words and blanks must be quoted.
         if (! doConvert && (s.isEmpty() || reservedWords.contains(s)))
            doConvert = true;
      }

      // If no conversion necessary, just print the attribute as-is.
      if (doConvert)
         stringValue(s);
      else
         w(s);

      return self();
   }

   /**
    * Adds a space only if the current indentation level is below maxIndent.
    *
    * @param indent The number of spaces to indent.
    * @return This object.
    */
   public SELF s(int indent) {
      if (indent <= maxIndent)
         super.s();
      return self();
   }

   /**
    * Performs an indentation only if we're currently past max indentation.
    *
    * @param depth The current indentation depth.
    * @return This object.
    */
   public SELF smi(int depth) {
      if (depth > maxIndent)
         super.s();
      return self();
   }

   /**
    * Serializes the specified object as a JSON string value.
    *
    * @param s The object being serialized.
    *    <br>Can be <jk>null</jk> (nothing is written).
    * @return This object.
    */
   public SELF stringValue(String s) {
      if (s == null)
         return self();
      boolean doConvert = false;
      for (var i = 0; i < s.length() && ! doConvert; i++) {
         var c = s.charAt(i);
         doConvert |= ec.contains(c);
      }
      q();
      if (! doConvert) {
         w(s);
      } else {
         for (var i = 0; i < s.length(); i++) {
            var c = s.charAt(i);
            if (ec.contains(c)) {
               if (c == '\n')
                  w('\\').w('n');
               else if (c == '\t')
                  w('\\').w('t');
               else if (c == '\b')
                  w('\\').w('b');
               else if (c == '\f')
                  w('\\').w('f');
               else if (c == quoteChar)
                  w('\\').w(quoteChar);
               else if (c == '\\')
                  w('\\').w('\\');
               else if (c == '/' && escapeSolidus)
                  w('\\').w('/');
               else if (c == '\r')
                  w('\\').w('r');
               else if (c < 0x20 || c == 0x7f)
                  w('\\').w('u').w('0').w('0').w(HEX[c >> 4]).w(HEX[c & 0xf]);
               else
                  w(c);
            } else {
               w(c);
            }
         }
      }
      q();
      return self();
   }

   /**
    * Appends a URI to the output.
    *
    * @param uri The URI to append to the output.
    * @return This object.
    */
   public SELF uriValue(Object uri) {
      return stringValue(uriResolver.resolve(uri));
   }
}