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

import static java.util.Collections.*;
import static org.apache.juneau.commons.utils.Shorts.*;

import java.io.*;
import java.util.*;
import java.util.function.*;

import org.apache.juneau.marshall.*;
import org.apache.juneau.marshall.json.*;
import org.apache.juneau.marshall.json5.*;
import org.apache.juneau.marshall.marshaller.*;
import org.apache.juneau.marshall.marshaller.Json;
import org.apache.juneau.marshall.parser.*;
import org.apache.juneau.marshall.serializer.*;

/**
 * Java implementation of a JSON object.
 *
 * <p>
 * This class is a subclass of {@link MarshalledMap} that carries strict-JSON-specific surface, including
 * strict-JSON {@link #toString()} (via {@link Json#of(Object)}), {@link JsonParser}-defaulting
 * {@link CharSequence} / {@link Reader} constructors, and convenience methods for serializing to the
 * various JSON dialects (JSON5, JSON Lines, canonical JSON, HJSON).
 *
 * <p>
 * <b>v10.0 behavioral break:</b> {@code toString()} now produces strict (RFC 8259) JSON (was JSON5),
 * and the {@link CharSequence} / {@link Reader} constructors now default to {@link JsonParser#DEFAULT}
 * (was {@link Json5Parser#DEFAULT}). For the previous JSON5 behavior use {@link Json5Map}.
 *
 * <p>
 * Note that the use of this class is optional for generating JSON. The serializers will accept any objects that implement the
 * {@link Map} interface.  But this class provides some useful additional functionality when working with
 * JSON models constructed from Java Collections Framework objects.  For example, a constructor is provided for
 * converting a JSON object string directly into a {@link Map}.  It also contains accessor methods for to avoid common
 * typecasting when accessing elements in a list.
 *
 * <h5 class='section'>Example:</h5>
 * <p class='bjava'>
 *    <jc>// Construct an empty Map</jc>
 *    JsonMap <jv>map</jv> = JsonMap.<jsm>of</jsm>();
 *
 *    <jc>// Construct a Map from JSON</jc>
 *    <jv>map</jv> = JsonMap.<jsm>ofString</jsm>(<js>"{a:'A',b:{c:'C',d:123}}"</js>);
 *
 *    <jc>// Construct a Map using the append method</jc>
 *    <jv>map</jv> = JsonMap.<jsm>of</jsm>().a(<js>"foo"</js>,<js>"x"</js>).a(<js>"bar"</js>,123).a(<js>"baz"</js>,<jk>true</jk>);
 *
 *    <jc>// Construct a Map from XML generated by XmlSerializer</jc>
 *    String <jv>xml</jv> = <js>"&lt;object&gt;&lt;a type='string'&gt;A&lt;/a&gt;&lt;b type='object'&gt;&lt;c type='string'&gt;C&lt;/c&gt;&lt;d type='number'&gt;123&lt;/d&gt;&lt;/b&gt;&lt;/object&gt;"</js>;
 *    <jv>map</jv> = JsonMap.<jsm>of</jsm>(<jv>xml</jv>, XmlParser.<jsf>DEFAULT</jsf>);
 *
 *    <jc>// Construct a Map from a URL GET parameter string generated by UrlEncodingParser</jc>
 *    String <jv>urlParams</jv> = <js>"?a='A'&amp;b={c:'C',d:123}"</js>;
 *    <jv>map</jv> = JsonMap.<jsm>of</jsm>(<jv>urlParams</jv>, UrlEncodingParser.<jsf>DEFAULT</jsf>);
 *
 *    <jc>// Construct JSON from JsonMap</jc>
 *    <jv>map</jv> = JsonMap.<jsm>ofString</jsm>(<js>"{foo:'bar'},{baz:[123,true]}"</js>);
 *    String <jv>json</jv> = <jv>map</jv>.toString();  <jc>// Produces "{foo:'bar'},{baz:[123,true]}"</jc>
 *    <jv>json</jv> = <jv>map</jv>.toString(JsonSerializer.<jsf>DEFAULT</jsf>);  <jc>// Equivalent</jc>
 *    <jv>json</jv> = JsonSerializer.<jsf>DEFAULT</jsf>.write(<jv>map</jv>);  <jc>// Equivalent</jc>
 *
 *    <jc>// Get a map entry as an Integer</jc>
 *    <jv>map</jv> = JsonMap.<jsm>ofString</jsm>(<js>"{foo:123}"</js>);
 *    Integer <jv>integer</jv> = <jv>map</jv>.getInt(<js>"foo"</js>);
 *    <jv>integer</jv> = <jv>map</jv>.get(Integer.<jk>class</jk>, <js>"foo"</js>);  <jc>// Equivalent</jc>
 *
 *    <jc>// Add an inner map</jc>
 *    JsonMap <jv>map1</jv> = JsonMap.<jsm>ofString</jsm>(<js>"{a:1}"</js>);
 *    JsonMap <jv>map2</jv> = JsonMap.<jsm>ofString</jsm>(<js>"{b:2}"</js>).setInner(<jv>map1</jv>);
 *    <jk>int</jk> <jv>_int</jv> = <jv>map2</jv>.getInt(<js>"a"</js>);  <jc>// a == 1 </jc>
 * </p>
 *
 * <h5 class='section'>Notes:</h5><ul>
 *    <li class='warn'>This class is not thread safe.
 * </ul>
 */
@SuppressWarnings({
   "java:S110", // JsonMap -> MarshalledMap -> LinkedHashMap -> HashMap -> AbstractMap: depth comes from the JDK map hierarchy
   "java:S2160", // equals() / hashCode() inherited from MarshalledMap; map equality is element-based
   "java:S9149" // Per-type static factories intentionally shadow the parent's.
})
public class JsonMap extends MarshalledMap {

   private static class Unmodifiable extends JsonMap {
      private static final long serialVersionUID = 1L;

      @SuppressWarnings({
         "synthetic-access" // Access to outer class members is intentional
      })
      Unmodifiable(JsonMap contents) {
         if (nn(contents))
            contents.forEach(super::put);
      }

      @Override
      public void clear() {
         throw uoroex();
      }

      @Override
      public Object compute(String key, BiFunction<? super String,? super Object,?> remappingFunction) {
         throw uoroex();
      }

      @Override
      public Object computeIfAbsent(String key, Function<? super String,?> mappingFunction) {
         throw uoroex();
      }

      @Override
      public Object computeIfPresent(String key, BiFunction<? super String,? super Object,?> remappingFunction) {
         throw uoroex();
      }

      @Override
      public Set<Map.Entry<String,Object>> entrySet() {
         return u(super.entrySet());
      }

      @Override
      public boolean isUnmodifiable() { return true; }

      @Override
      public Set<String> keySet() {
         return u(super.keySet());
      }

      @Override
      public Object merge(String key, Object value, BiFunction<? super Object,? super Object,?> remappingFunction) {
         throw uoroex();
      }

      @Override
      public Object put(String key, Object val) {
         throw uoroex();
      }

      @Override
      public void putAll(Map<? extends String,?> m) {
         throw uoroex();
      }

      @Override
      public Object putIfAbsent(String key, Object value) {
         throw uoroex();
      }

      @Override
      public Object remove(Object key) {
         throw uoroex();
      }

      @Override
      public boolean remove(Object key, Object value) {
         throw uoroex();
      }

      @Override
      public Object replace(String key, Object value) {
         throw uoroex();
      }

      @Override
      public boolean replace(String key, Object oldValue, Object newValue) {
         throw uoroex();
      }

      @Override
      public void replaceAll(BiFunction<? super String,? super Object,?> function) {
         throw uoroex();
      }

      @Override
      public Collection<Object> values() {
         return Collections.unmodifiableCollection(super.values());
      }
   }

   private static final long serialVersionUID = 1L;

   /**
    * An empty read-only JsonMap.
    *
    * @serial exclude
    */
   @SuppressWarnings({
      "java:S2386" // Public static final field accessed externally, cannot be protected
   })
   public static final JsonMap EMPTY_MAP = new JsonMap() {

      private static final long serialVersionUID = 1L;

      @Override /* Overridden from Map */
      public Set<Map.Entry<String,Object>> entrySet() {
         return Collections.<String,Object>emptyMap().entrySet();
      }

      @Override /* Overridden from Map */
      public Set<String> keySet() {
         return Collections.<String,Object>emptyMap().keySet();
      }

      @Override /* Overridden from Map */
      public Object put(String key, Object value) {
         throw uoroex();
      }

      @Override /* Overridden from Map */
      public Object remove(Object key) {
         throw uoroex();
      }

      @Override /* Overridden from Map */
      public Collection<Object> values() {
         return emptyMap().values();
      }
   };

   /**
    * Construct an empty map.
    *
    * @return An empty map.
    */
   public static JsonMap create() {
      return new JsonMap();
   }

   /**
    * Construct an empty filtered map.
    *
    * @return An empty map.
    */
   public static JsonMap filteredMap() {
      return create().filtered();
   }

   /**
    * Construct a filtered map initialized with the specified key/value pairs.
    *
    * <p>
    * Same as {@link #of(Object...)} but calls {@link #filtered()} on the created map.
    *
    * @param keyValuePairs A list of key/value pairs to add to this map.
    * @return A new map, never <jk>null</jk>.
    */
   public static JsonMap filteredMap(Object...keyValuePairs) {
      return new JsonMap(keyValuePairs).filtered();
   }

   /**
    * Construct a map initialized with the specified map.
    *
    * @param values
    *    The map to copy.
    *    <br>Can be <jk>null</jk> (returns <jk>null</jk>).
    *    <br>Keys will be converted to strings using {@link Object#toString()}.
    * @return A new map or <jk>null</jk> if the map was <jk>null</jk>.
    */
   public static JsonMap of(Map<?,?> values) {
      return values == null ? null : new JsonMap(values);
   }

   /**
    * Construct a map initialized with the specified key/value pairs.
    *
    * <h5 class='section'>Examples:</h5>
    * <p class='bjava'>
    *    JsonMap <jv>map</jv> = <jk>new</jk> JsonMap(<js>"key1"</js>,<js>"val1"</js>,<js>"key2"</js>,<js>"val2"</js>);
    * </p>
    *
    * @param keyValuePairs A list of key/value pairs to add to this map.
    * @return A new map, never <jk>null</jk>.
    */
   public static JsonMap of(Object...keyValuePairs) {
      return new JsonMap(keyValuePairs);
   }

   /**
    * Construct a map initialized with the specified JSON string.
    *
    * @param json
    *    The JSON text to parse.
    *    <br>Can be normal or simplified JSON.
    * @return A new map (empty if the input was <jk>null</jk>), never <jk>null</jk>.
    * @throws ParseException Malformed input encountered.
    */
   public static JsonMap ofString(CharSequence json) throws ParseException {
      return json == null ? new JsonMap() : new JsonMap(json);
   }

   /**
    * Construct a map initialized with the specified reader containing JSON.
    *
    * @param json
    *    The reader containing JSON text to parse.
    *    <br>Can contain normal or simplified JSON.
    * @return A new map (empty if the input was <jk>null</jk>), never <jk>null</jk>.
    * @throws ParseException Malformed input encountered.
    */
   public static JsonMap ofString(Reader json) throws ParseException {
      return json == null ? new JsonMap() : new JsonMap(json);
   }

   /**
    * Construct a map initialized with the specified string.
    *
    * @param in The input being parsed.
    * @param p
    *    The parser to use to parse the input.
    *    <br>If <jk>null</jk>, uses {@link JsonParser}.
    * @return A new map (empty if the input was <jk>null</jk>), never <jk>null</jk>.
    * @throws ParseException Malformed input encountered.
    */
   public static JsonMap ofString(CharSequence in, Parser p) throws ParseException {
      return in == null ? new JsonMap() : new JsonMap(in, p);
   }

   /**
    * Construct a map initialized with the specified string.
    *
    * @param in
    *    The reader containing the input being parsed.
    *    <br>Can contain normal or simplified JSON.
    * @param p
    *    The parser to use to parse the input.
    *    <br>If <jk>null</jk>, uses {@link JsonParser}.
    * @return A new map (empty if the input was <jk>null</jk>), never <jk>null</jk>.
    * @throws ParseException Malformed input encountered.
    */
   public static JsonMap ofString(Reader in, Parser p) throws ParseException {
      return in == null ? new JsonMap() : new JsonMap(in, p);
   }

   /**
    * Construct an empty map.
    */
   public JsonMap() {}

   /**
    * Construct an empty map with the specified bean context.
    *
    * @param session The bean session to use for creating beans.
    */
   public JsonMap(MarshallingSession session) {
      super(session);
   }

   /**
    * Construct a map initialized with the specified JSON.
    *
    * @param json
    *    The JSON text to parse.
    *    <br>Must be strict (RFC 8259) JSON; for JSON5 input use {@link Json5Map} or pass
    *    {@link Json5Parser#DEFAULT} explicitly.
    * @throws ParseException Malformed input encountered.
    */
   public JsonMap(CharSequence json) throws ParseException {
      this(json, JsonParser.DEFAULT);
   }

   /**
    * Construct a map initialized with the specified string.
    *
    * @param in
    *    The input being parsed.
    *    <br>Can be <jk>null</jk> or empty (results in an empty map; no parsing occurs).
    * @param p
    *    The parser to use to parse the input.
    *    <br>If <jk>null</jk>, uses {@link JsonParser}.
    * @throws ParseException Malformed input encountered.
    */
   public JsonMap(CharSequence in, Parser p) throws ParseException {
      super(in, p == null ? JsonParser.DEFAULT : p);
   }

   /**
    * Construct a map initialized with the specified map.
    *
    * @param in
    *    The map to copy.
    *    <br>Can be <jk>null</jk> (results in an empty map).
    *    <br>Keys will be converted to strings using {@link Object#toString()}.
    */
   public JsonMap(Map<?,?> in) {
      super(in);
   }

   /**
    * Construct a map initialized with the specified key/value pairs.
    *
    * <h5 class='section'>Examples:</h5>
    * <p class='bjava'>
    *    JsonMap <jv>map</jv> = <jk>new</jk> JsonMap(<js>"key1"</js>,<js>"val1"</js>,<js>"key2"</js>,<js>"val2"</js>);
    * </p>
    *
    * @param keyValuePairs A list of key/value pairs to add to this map.
    */
   public JsonMap(Object...keyValuePairs) {
      super(keyValuePairs);
   }

   /**
    * Construct a map initialized with the specified reader containing JSON.
    *
    * @param json
    *    The reader containing JSON text to parse.
    *    <br>Must be strict (RFC 8259) JSON; for JSON5 input use {@link Json5Map} or pass
    *    {@link Json5Parser#DEFAULT} explicitly.
    * @throws ParseException Malformed input encountered.
    */
   public JsonMap(Reader json) throws ParseException {
      this(json, JsonParser.DEFAULT);
   }

   /**
    * Construct a map initialized with the specified string.
    *
    * @param in
    *    The reader containing the input being parsed.
    *    <br>Must be strict (RFC 8259) JSON.
    * @param p
    *    The parser to use to parse the input.
    *    <br>If <jk>null</jk>, uses {@link JsonParser}.
    * @throws ParseException Malformed input encountered.
    */
   public JsonMap(Reader in, Parser p) throws ParseException {
      super(in, p == null ? JsonParser.DEFAULT : p);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap append(Map<String,Object> values) {
      super.append(values);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap append(String key, Object value) {
      super.append(key, value);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   @SuppressWarnings({
      "unchecked", // Generic varargs is safe here: values are only iterated, not stored into a typed array.
      "varargs" // values is only forwarded to super.appendFirst(), never stored or exposed, so heap pollution cannot occur
   })
   public <T> JsonMap appendFirst(Predicate<T> test, String key, T...values) {
      super.appendFirst(test, key, values);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap appendIf(boolean flag, String key, Object value) {
      super.appendIf(flag, key, value);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public <T> JsonMap appendIf(Predicate<T> test, String key, T value) {
      super.appendIf(test, key, value);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap appendIfAbsent(String key, Object value) {
      super.appendIfAbsent(key, value);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public <T> JsonMap appendIfAbsentIf(Predicate<T> predicate, String key, T value) {
      super.appendIfAbsentIf(predicate, key, value);
      return this;
   }

   /**
    * Serializes this map to a standard JSON string.
    *
    * @return This object as a standard JSON string.
    */
   public String toJson() {
      return Json.of(this);
   }

   /**
    * Serializes this map to a JSON5 string.
    *
    * <p>
    * A synonym for {@link #toString()}.
    *
    * @return This object as a JSON5 string.
    */
   public String toJson5() {
      return Json5.of(this);
   }

   /**
    * Serializes this map to a JSON Lines string.
    *
    * @return This object as a JSON Lines string.
    */
   public String toJsonl() {
      return Jsonl.of(this);
   }

   /**
    * Serializes this map to a canonical JSON string (RFC 8785).
    *
    * @return This object as a canonical JSON string.
    */
   public String toJcs() {
      return Jcs.of(this);
   }

   /**
    * Serializes this map to an HJSON string.
    *
    * @return This object as an HJSON string.
    */
   public String toHjson() {
      return Hjson.of(this);
   }

   /**
    * Serializes this map to a readable (indented) JSON5 string using {@link Json5Serializer#DEFAULT_READABLE}.
    *
    * @return This object serialized as a readable JSON5 string.
    */
   public String toReadableJson5() {
      if (Json5Serializer.DEFAULT_READABLE == null)
         return s(this);
      return Json5Serializer.DEFAULT_READABLE.toString(this);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap exclude(String...keys) {
      var m2 = new JsonMap();
      this.forEach((k, v) -> {
         var exclude = false;
         for (var kk : keys)
            if (kk.equals(k))
               exclude = true;
         if (! exclude)
            m2.put(k, v);
      });
      return m2;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap filtered() {
      super.filtered();
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap filtered(Predicate<Object> value) {
      super.filtered(value);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonList findList(String...keys) {
      return find(JsonList.class, keys);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap findMap(String...keys) {
      return find(JsonMap.class, keys);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonList getList(String key) {
      return get(key, JsonList.class);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonList getList(String key, boolean createIfNotExists) {
      JsonList m = getWithDefault(key, null, JsonList.class);
      if (m == null && createIfNotExists) {
         m = new JsonList();
         put(key, m);
      }
      return m;
   }

   /**
    * Returns the specified entry value converted to a {@link JsonList}.
    *
    * @param key The key.
    * @param defVal The default value if the map doesn't contain the specified mapping.
    * @return The converted value, or the default value if the map contains no mapping for this key.
    * @throws InvalidDataConversionException If value cannot be converted.
    */
   public JsonList getList(String key, JsonList defVal) {
      return getWithDefault(key, defVal, JsonList.class);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap getMap(String key) {
      return get(key, JsonMap.class);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap getMap(String key, boolean createIfNotExists) {
      var m = getWithDefault(key, null, JsonMap.class);
      if (m == null && createIfNotExists) {
         m = new JsonMap();
         put(key, m);
      }
      return m;
   }

   /**
    * Returns the specified entry value converted to a {@link JsonMap}.
    *
    * @param key The key.
    * @param defVal The default value if the map doesn't contain the specified mapping.
    * @return The converted value, or the default value if the map contains no mapping for this key.
    * @throws InvalidDataConversionException If value cannot be converted.
    */
   public JsonMap getMap(String key, JsonMap defVal) {
      return getWithDefault(key, defVal, JsonMap.class);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap include(String...keys) {
      var m2 = new JsonMap();
      this.forEach((k, v) -> {
         for (var kk : keys)
            if (kk.equals(k))
               m2.put(kk, v);
      });
      return m2;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap inner(Map<String,Object> inner) {
      super.inner(inner);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap keepAll(String...keys) {
      super.keepAll(keys);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap modifiable() {
      if (isUnmodifiable())
         return new JsonMap(this);
      return this;
   }

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

   /**
    * Convenience method for inserting JSON directly into an attribute on this object.
    *
    * <p>
    * The JSON text can be an object (i.e. <js>"{...}"</js>) or an array (i.e. <js>"[...]"</js>).
    *
    * <p>
    * Input must be strict (RFC 8259) JSON; for JSON5 use {@link Json5Map#putJson5(String,String)}.
    *
    * @param key The key.
    * @param json The JSON text that will be parsed into an Object and then inserted into this map.
    * @throws ParseException Malformed input encountered.
    */
   public void putJson(String key, String json) throws ParseException {
      this.put(key, Json.to(json, Object.class));
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap session(MarshallingSession session) {
      super.session(session);
      return this;
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap setBeanSession(MarshallingSession value) {
      super.setBeanSession(value);
      return this;
   }

   @Override /* Overridden from Object */
   public String toString() {
      return Json.of(this);
   }

   @Override /* Overridden from MarshalledMap */
   public JsonMap unmodifiable() {
      if (this instanceof Unmodifiable this2)
         return this2;
      return new Unmodifiable(this);
   }

   /**
    * Convenience method for serializing this map to the specified <c>Writer</c> using the
    * {@link Json#DEFAULT} marshaller.
    *
    * @param w The writer to serialize this object to.
    * @return This object.
    * @throws IOException If a problem occurred trying to write to the writer.
    * @throws SerializeException If a problem occurred trying to convert the output.
    */
   public JsonMap writeTo(Writer w) throws IOException, SerializeException {
      Json.DEFAULT.write(this, w);
      return this;
   }
}