content: /* Copyright (C) 2016-2018 Alibaba Group Holding Limited
  
  Licensed 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.
  ==============================================================================*/
  
  // Protocol Buffers - Google's data interchange format
  // Copyright 2008 Google Inc.  All rights reserved.
  // https://developers.google.com/protocol-buffers/
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are
  // met:
  //
  //     * Redistributions of source code must retain the above copyright
  // notice, this list of conditions and the following disclaimer.
  //     * Redistributions in binary form must reproduce the above
  // copyright notice, this list of conditions and the following disclaimer
  // in the documentation and/or other materials provided with the
  // distribution.
  //     * Neither the name of Google Inc. nor the names of its
  // contributors may be used to endorse or promote products derived from
  // this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  package com.google.protobuf.util;
  
  import com.google.common.base.Preconditions;
  import com.google.common.io.BaseEncoding;
  import com.google.gson.Gson;
  import com.google.gson.GsonBuilder;
  import com.google.gson.JsonArray;
  import com.google.gson.JsonElement;
  import com.google.gson.JsonIOException;
  import com.google.gson.JsonNull;
  import com.google.gson.JsonObject;
  import com.google.gson.JsonParser;
  import com.google.gson.JsonPrimitive;
  import com.google.gson.stream.JsonReader;
  import com.google.protobuf.Any;
  import com.google.protobuf.BoolValue;
  import com.google.protobuf.ByteString;
  import com.google.protobuf.BytesValue;
  import com.google.protobuf.Descriptors.Descriptor;
  import com.google.protobuf.Descriptors.EnumDescriptor;
  import com.google.protobuf.Descriptors.EnumValueDescriptor;
  import com.google.protobuf.Descriptors.FieldDescriptor;
  import com.google.protobuf.Descriptors.FileDescriptor;
  import com.google.protobuf.Descriptors.OneofDescriptor;
  import com.google.protobuf.DoubleValue;
  import com.google.protobuf.Duration;
  import com.google.protobuf.DynamicMessage;
  import com.google.protobuf.FieldMask;
  import com.google.protobuf.FloatValue;
  import com.google.protobuf.Int32Value;
  import com.google.protobuf.Int64Value;
  import com.google.protobuf.InvalidProtocolBufferException;
  import com.google.protobuf.ListValue;
  import com.google.protobuf.Message;
  import com.google.protobuf.MessageOrBuilder;
  import com.google.protobuf.NullValue;
  import com.google.protobuf.StringValue;
  import com.google.protobuf.Struct;
  import com.google.protobuf.Timestamp;
  import com.google.protobuf.UInt32Value;
  import com.google.protobuf.UInt64Value;
  import com.google.protobuf.Value;
  import java.io.IOException;
  import java.io.Reader;
  import java.io.StringReader;
  import java.math.BigDecimal;
  import java.math.BigInteger;
  import java.text.ParseException;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeMap;
  import java.util.logging.Logger;
  
  /**
   * Utility classes to convert protobuf messages to/from JSON format. The JSON
   * format follows Proto3 JSON specification and only proto3 features are
   * supported. Proto2 only features (e.g., extensions and unknown fields) will
   * be discarded in the conversion. That is, when converting proto2 messages
   * to JSON format, extensions and unknown fields will be treated as if they
   * do not exist. This applies to proto2 messages embedded in proto3 messages
   * as well.
   */
  public class JsonFormat {
    private static final Logger logger = Logger.getLogger(JsonFormat.class.getName());
  
    private JsonFormat() {}
  
    /**
     * Creates a {@link Printer} with default configurations.
     */
    public static Printer printer() {
      return new Printer(
          TypeRegistry.getEmptyTypeRegistry(), false, Collections.<FieldDescriptor>emptySet(),
          false, false, false);
    }
  
    /**
     * A Printer converts protobuf message to JSON format.
     */
    public static class Printer {
      private final TypeRegistry registry;
      // NOTE: There are 3 states for these *defaultValueFields variables:
      // 1) Default - alwaysOutput is false & including is empty set. Fields only output if they are
      //    set to non-default values.
      // 2) No-args includingDefaultValueFields() called - alwaysOutput is true & including is
      //    irrelevant (but set to empty set). All fields are output regardless of their values.
      // 3) includingDefaultValueFields(Set<FieldDescriptor>) called - alwaysOutput is false &
      //    including is set to the specified set. Fields in that set are always output & fields not
      //    in that set are only output if set to non-default values.
      private boolean alwaysOutputDefaultValueFields;
      private Set<FieldDescriptor> includingDefaultValueFields;
      private final boolean preservingProtoFieldNames;
      private final boolean omittingInsignificantWhitespace;
      private final boolean printingEnumsAsInts;
  
      private Printer(
          TypeRegistry registry,
          boolean alwaysOutputDefaultValueFields,
          Set<FieldDescriptor> includingDefaultValueFields,
          boolean preservingProtoFieldNames,
          boolean omittingInsignificantWhitespace,
          boolean printingEnumsAsInts) {
        this.registry = registry;
        this.alwaysOutputDefaultValueFields = alwaysOutputDefaultValueFields;
        this.includingDefaultValueFields = includingDefaultValueFields;
        this.preservingProtoFieldNames = preservingProtoFieldNames;
        this.omittingInsignificantWhitespace = omittingInsignificantWhitespace;
        this.printingEnumsAsInts = printingEnumsAsInts;
      }
  
      /**
       * Creates a new {@link Printer} using the given registry. The new Printer
       * clones all other configurations from the current {@link Printer}.
       *
       * @throws IllegalArgumentException if a registry is already set.
       */
      public Printer usingTypeRegistry(TypeRegistry registry) {
        if (this.registry != TypeRegistry.getEmptyTypeRegistry()) {
          throw new IllegalArgumentException("Only one registry is allowed.");
        }
        return new Printer(
            registry,
            alwaysOutputDefaultValueFields,
            includingDefaultValueFields,
            preservingProtoFieldNames,
            omittingInsignificantWhitespace,
            printingEnumsAsInts);
      }
  
      /**
       * Creates a new {@link Printer} that will also print fields set to their
       * defaults. Empty repeated fields and map fields will be printed as well.
       * The new Printer clones all other configurations from the current
       * {@link Printer}.
       */
      public Printer includingDefaultValueFields() {
        checkUnsetIncludingDefaultValueFields();
        return new Printer(
            registry,
            true,
            Collections.<FieldDescriptor>emptySet(),
            preservingProtoFieldNames,
            omittingInsignificantWhitespace,
            printingEnumsAsInts);
      }
  
      /**
       * Creates a new {@link Printer} that will print enum field values as integers instead of as
       * string.
       * The new Printer clones all other configurations from the current
       * {@link Printer}.
       */
      public Printer printingEnumsAsInts() {
        checkUnsetPrintingEnumsAsInts();
        return new Printer(
            registry,
            alwaysOutputDefaultValueFields,
            Collections.<FieldDescriptor>emptySet(),
            preservingProtoFieldNames,
            omittingInsignificantWhitespace,
            true);
      }
  
      private void checkUnsetPrintingEnumsAsInts() {
        if (printingEnumsAsInts) {
          throw new IllegalStateException("JsonFormat printingEnumsAsInts has already been set.");
        }
      }
  
      /**
       * Creates a new {@link Printer} that will also print default-valued fields if their
       * FieldDescriptors are found in the supplied set. Empty repeated fields and map fields will be
       * printed as well, if they match. The new Printer clones all other configurations from the
       * current {@link Printer}. Call includingDefaultValueFields() with no args to unconditionally
       * output all fields.
       */
      public Printer includingDefaultValueFields(Set<FieldDescriptor> fieldsToAlwaysOutput) {
        Preconditions.checkArgument(
            null != fieldsToAlwaysOutput && !fieldsToAlwaysOutput.isEmpty(),
            "Non-empty Set must be supplied for includingDefaultValueFields.");
  
        checkUnsetIncludingDefaultValueFields();
        return new Printer(
            registry,
            false,
            fieldsToAlwaysOutput,
            preservingProtoFieldNames,
            omittingInsignificantWhitespace,
            printingEnumsAsInts);
      }
  
      private void checkUnsetIncludingDefaultValueFields() {
        if (alwaysOutputDefaultValueFields || !includingDefaultValueFields.isEmpty()) {
          throw new IllegalStateException(
              "JsonFormat includingDefaultValueFields has already been set.");
        }
      }
  
      /**
       * Creates a new {@link Printer} that is configured to use the original proto
       * field names as defined in the .proto file rather than converting them to
       * lowerCamelCase. The new Printer clones all other configurations from the
       * current {@link Printer}.
       */
      public Printer preservingProtoFieldNames() {
        return new Printer(
            registry,
            alwaysOutputDefaultValueFields,
            includingDefaultValueFields,
            true,
            omittingInsignificantWhitespace,
            printingEnumsAsInts);
      }
  
  
      /**
       * Create a new {@link Printer} that will omit all insignificant whitespace in the JSON output.
       * This new Printer clones all other configurations from the current Printer. Insignificant
       * whitespace is defined by the JSON spec as whitespace that appear between JSON structural
       * elements:
       *
       * <pre>
       * ws = *(
       * %x20 /              ; Space
       * %x09 /              ; Horizontal tab
       * %x0A /              ; Line feed or New line
       * %x0D )              ; Carriage return
       * </pre>
       *
       * See <a href="https://tools.ietf.org/html/rfc7159">https://tools.ietf.org/html/rfc7159</a>
       * current {@link Printer}.
       */
      public Printer omittingInsignificantWhitespace() {
        return new Printer(
            registry,
            alwaysOutputDefaultValueFields,
            includingDefaultValueFields,
            preservingProtoFieldNames,
            true,
            printingEnumsAsInts);
      }
  
      /**
       * Converts a protobuf message to JSON format.
       *
       * @throws InvalidProtocolBufferException if the message contains Any types that can't be
       *     resolved.
       * @throws IOException if writing to the output fails.
       */
      public void appendTo(MessageOrBuilder message, Appendable output) throws IOException {
        // TODO(xiaofeng): Investigate the allocation overhead and optimize for
        // mobile.
        new PrinterImpl(
                registry,
                alwaysOutputDefaultValueFields,
                includingDefaultValueFields,
                preservingProtoFieldNames,
                output,
                omittingInsignificantWhitespace,
                printingEnumsAsInts)
            .print(message);
      }
  
      /**
       * Converts a protobuf message to JSON format. Throws exceptions if there
       * are unknown Any types in the message.
       */
      public String print(MessageOrBuilder message) throws InvalidProtocolBufferException {
        try {
          StringBuilder builder = new StringBuilder();
          appendTo(message, builder);
          return builder.toString();
        } catch (InvalidProtocolBufferException e) {
          throw e;
        } catch (IOException e) {
          // Unexpected IOException.
          throw new IllegalStateException(e);
        }
      }
    }
  
    /**
     * Creates a {@link Parser} with default configuration.
     */
    public static Parser parser() {
      return new Parser(TypeRegistry.getEmptyTypeRegistry(), false, Parser.DEFAULT_RECURSION_LIMIT);
    }
  
    /**
     * A Parser parses JSON to protobuf message.
     */
    public static class Parser {
      private final TypeRegistry registry;
      private final boolean ignoringUnknownFields;
      private final int recursionLimit;
  
      // The default parsing recursion limit is aligned with the proto binary parser.
      private static final int DEFAULT_RECURSION_LIMIT = 100;
  
      private Parser(TypeRegistry registry, boolean ignoreUnknownFields, int recursionLimit) {
        this.registry = registry;
        this.ignoringUnknownFields = ignoreUnknownFields;
        this.recursionLimit = recursionLimit;
      }
  
      /**
       * Creates a new {@link Parser} using the given registry. The new Parser
       * clones all other configurations from this Parser.
       *
       * @throws IllegalArgumentException if a registry is already set.
       */
      public Parser usingTypeRegistry(TypeRegistry registry) {
        if (this.registry != TypeRegistry.getEmptyTypeRegistry()) {
          throw new IllegalArgumentException("Only one registry is allowed.");
        }
        return new Parser(registry, ignoringUnknownFields, recursionLimit);
      }
  
      /**
       * Creates a new {@link Parser} configured to not throw an exception when an unknown field is
       * encountered. The new Parser clones all other configurations from this Parser.
       */
      public Parser ignoringUnknownFields() {
        return new Parser(this.registry, true, recursionLimit);
      }
  
      /**
       * Parses from JSON into a protobuf message.
       *
       * @throws InvalidProtocolBufferException if the input is not valid JSON
       *         format or there are unknown fields in the input.
       */
      public void merge(String json, Message.Builder builder) throws InvalidProtocolBufferException {
        // TODO(xiaofeng): Investigate the allocation overhead and optimize for
        // mobile.
        new ParserImpl(registry, ignoringUnknownFields, recursionLimit).merge(json, builder);
      }
  
      /**
       * Parses from JSON into a protobuf message.
       *
       * @throws InvalidProtocolBufferException if the input is not valid JSON
       *         format or there are unknown fields in the input.
       * @throws IOException if reading from the input throws.
       */
      public void merge(Reader json, Message.Builder builder) throws IOException {
        // TODO(xiaofeng): Investigate the allocation overhead and optimize for
        // mobile.
        new ParserImpl(registry, ignoringUnknownFields, recursionLimit).merge(json, builder);
      }
  
      // For testing only.
      Parser usingRecursionLimit(int recursionLimit) {
        return new Parser(registry, ignoringUnknownFields, recursionLimit);
      }
    }
  
    /**
     * A TypeRegistry is used to resolve Any messages in the JSON conversion.
     * You must provide a TypeRegistry containing all message types used in
     * Any message fields, or the JSON conversion will fail because data
     * in Any message fields is unrecognizable. You don't need to supply a
     * TypeRegistry if you don't use Any message fields.
     */
    public static class TypeRegistry {
      private static class EmptyTypeRegistryHolder {
        private static final TypeRegistry EMPTY =
            new TypeRegistry(Collections.<String, Descriptor>emptyMap());
      }
  
      public static TypeRegistry getEmptyTypeRegistry() {
        return EmptyTypeRegistryHolder.EMPTY;
      }
  
      public static Builder newBuilder() {
        return new Builder();
      }
  
      /**
       * Find a type by its full name. Returns null if it cannot be found in
       * this {@link TypeRegistry}.
       */
      public Descriptor find(String name) {
        return types.get(name);
      }
  
      private final Map<String, Descriptor> types;
  
      private TypeRegistry(Map<String, Descriptor> types) {
        this.types = types;
      }
  
      /**
       * A Builder is used to build {@link TypeRegistry}.
       */
      public static class Builder {
        private Builder() {}
  
        /**
         * Adds a message type and all types defined in the same .proto file as
         * well as all transitively imported .proto files to this {@link Builder}.
         */
        public Builder add(Descriptor messageType) {
          if (types == null) {
            throw new IllegalStateException("A TypeRegistry.Builer can only be used once.");
          }
          addFile(messageType.getFile());
          return this;
        }
  
        /**
         * Adds message types and all types defined in the same .proto file as
         * well as all transitively imported .proto files to this {@link Builder}.
         */
        public Builder add(Iterable<Descriptor> messageTypes) {
          if (types == null) {
            throw new IllegalStateException("A TypeRegistry.Builder can only be used once.");
          }
          for (Descriptor type : messageTypes) {
            addFile(type.getFile());
          }
          return this;
        }
  
        /**
         * Builds a {@link TypeRegistry}. This method can only be called once for
         * one Builder.
         */
        public TypeRegistry build() {
          TypeRegistry result = new TypeRegistry(types);
          // Make sure the built {@link TypeRegistry} is immutable.
          types = null;
          return result;
        }
  
        private void addFile(FileDescriptor file) {
          // Skip the file if it's already added.
          if (!files.add(file.getFullName())) {
            return;
          }
          for (FileDescriptor dependency : file.getDependencies()) {
            addFile(dependency);
          }
          for (Descriptor message : file.getMessageTypes()) {
            addMessage(message);
          }
        }
  
        private void addMessage(Descriptor message) {
          for (Descriptor nestedType : message.getNestedTypes()) {
            addMessage(nestedType);
          }
  
          if (types.containsKey(message.getFullName())) {
            logger.warning("Type " + message.getFullName() + " is added multiple times.");
            return;
          }
  
          types.put(message.getFullName(), message);
        }
  
        private final Set<String> files = new HashSet<String>();
        private Map<String, Descriptor> types = new HashMap<String, Descriptor>();
      }
    }
  
    /**
     * An interface for json formatting that can be used in
     * combination with the omittingInsignificantWhitespace() method
     */
    interface TextGenerator {
      void indent();
  
      void outdent();
  
      void print(final CharSequence text) throws IOException;
    }
  
    /**
     * Format the json without indentation
     */
    private static final class CompactTextGenerator implements TextGenerator {
      private final Appendable output;
  
      private CompactTextGenerator(final Appendable output) {
        this.output = output;
      }
  
      /** ignored by compact printer */
      @Override
      public void indent() {}
  
      /** ignored by compact printer */
      @Override
      public void outdent() {}
  
      /** Print text to the output stream. */
      @Override
      public void print(final CharSequence text) throws IOException {
        output.append(text);
      }
    }
    /**
     * A TextGenerator adds indentation when writing formatted text.
     */
    private static final class PrettyTextGenerator implements TextGenerator {
      private final Appendable output;
      private final StringBuilder indent = new StringBuilder();
      private boolean atStartOfLine = true;
  
      private PrettyTextGenerator(final Appendable output) {
        this.output = output;
      }
  
      /**
       * Indent text by two spaces. After calling Indent(), two spaces will be inserted at the
       * beginning of each line of text. Indent() may be called multiple times to produce deeper
       * indents.
       */
      @Override
      public void indent() {
        indent.append("  ");
      }
  
      /** Reduces the current indent level by two spaces, or crashes if the indent level is zero. */
      @Override
      public void outdent() {
        final int length = indent.length();
        if (length < 2) {
          throw new IllegalArgumentException(" Outdent() without matching Indent().");
        }
        indent.delete(length - 2, length);
      }
  
      /** Print text to the output stream. */
      @Override
      public void print(final CharSequence text) throws IOException {
        final int size = text.length();
        int pos = 0;
  
        for (int i = 0; i < size; i++) {
          if (text.charAt(i) == '\n') {
            write(text.subSequence(pos, i + 1));
            pos = i + 1;
            atStartOfLine = true;
          }
        }
        write(text.subSequence(pos, size));
      }
  
      private void write(final CharSequence data) throws IOException {
        if (data.length() == 0) {
          return;
        }
        if (atStartOfLine) {
          atStartOfLine = false;
          output.append(indent);
        }
        output.append(data);
      }
    }
  
    /**
     * A Printer converts protobuf messages to JSON format.
     */
    private static final class PrinterImpl {
      private final TypeRegistry registry;
      private final boolean alwaysOutputDefaultValueFields;
      private final Set<FieldDescriptor> includingDefaultValueFields;
      private final boolean preservingProtoFieldNames;
      private final boolean printingEnumsAsInts;
      private final TextGenerator generator;
      // We use Gson to help handle string escapes.
      private final Gson gson;
      private final CharSequence blankOrSpace;
      private final CharSequence blankOrNewLine;
  
      private static class GsonHolder {
        private static final Gson DEFAULT_GSON = new GsonBuilder().disableHtmlEscaping().create();
      }
  
      PrinterImpl(
          TypeRegistry registry,
          boolean alwaysOutputDefaultValueFields,
          Set<FieldDescriptor> includingDefaultValueFields,
          boolean preservingProtoFieldNames,
          Appendable jsonOutput,
          boolean omittingInsignificantWhitespace,
          boolean printingEnumsAsInts) {
        this.registry = registry;
        this.alwaysOutputDefaultValueFields = alwaysOutputDefaultValueFields;
        this.includingDefaultValueFields = includingDefaultValueFields;
        this.preservingProtoFieldNames = preservingProtoFieldNames;
        this.printingEnumsAsInts = printingEnumsAsInts;
        this.gson = GsonHolder.DEFAULT_GSON;
        // json format related properties, determined by printerType
        if (omittingInsignificantWhitespace) {
          this.generator = new CompactTextGenerator(jsonOutput);
          this.blankOrSpace = "";
          this.blankOrNewLine = "";
        } else {
          this.generator = new PrettyTextGenerator(jsonOutput);
          this.blankOrSpace = " ";
          this.blankOrNewLine = "\n";
        }
      }
  
      void print(MessageOrBuilder message) throws IOException {
        WellKnownTypePrinter specialPrinter =
            wellKnownTypePrinters.get(message.getDescriptorForType().getFullName());
        if (specialPrinter != null) {
          specialPrinter.print(this, message);
          return;
        }
        print(message, null);
      }
  
      private interface WellKnownTypePrinter {
        void print(PrinterImpl printer, MessageOrBuilder message) throws IOException;
      }
  
      private static final Map<String, WellKnownTypePrinter> wellKnownTypePrinters =
          buildWellKnownTypePrinters();
  
      private static Map<String, WellKnownTypePrinter> buildWellKnownTypePrinters() {
        Map<String, WellKnownTypePrinter> printers = new HashMap<String, WellKnownTypePrinter>();
        // Special-case Any.
        printers.put(
            Any.getDescriptor().getFullName(),
            new WellKnownTypePrinter() {
              @Override
              public void print(PrinterImpl printer, MessageOrBuilder message) throws IOException {
                printer.printAny(message);
              }
            });
        // Special-case wrapper types.
        WellKnownTypePrinter wrappersPrinter =
            new WellKnownTypePrinter() {
              @Override
              public void print(PrinterImpl printer, MessageOrBuilder message) throws IOException {
                printer.printWrapper(message);
              }
            };
        printers.put(BoolValue.getDescriptor().getFullName(), wrappersPrinter);
        printers.put(Int32Value.getDescriptor().getFullName(), wrappersPrinter);
        printers.put(UInt32Value.getDescriptor().getFullName(), wrappersPrinter);
        printers.put(Int64Value.getDescriptor().getFullName(), wrappersPrinter);
        printers.put(UInt64Value.getDescriptor().getFullName(), wrappersPrinter);
        printers.put(StringValue.getDescriptor().getFullName(), wrappersPrinter);
        printers.put(BytesValue.getDescriptor().getFullName(), wrappersPrinter);
        printers.put(FloatValue.getDescriptor().getFullName(), wrappersPrinter);
        printers.put(DoubleValue.getDescriptor().getFullName(), wrappersPrinter);
        // Special-case Timestamp.
        printers.put(
            Timestamp.getDescriptor().getFullName(),
            new WellKnownTypePrinter() {
              @Override
              public void print(PrinterImpl printer, MessageOrBuilder message) throws IOException {
                printer.printTimestamp(message);
              }
            });
        // Special-case Duration.
        printers.put(
            Duration.getDescriptor().getFullName(),
            new WellKnownTypePrinter() {
              @Override
              public void print(PrinterImpl printer, MessageOrBuilder message) throws IOException {
                printer.printDuration(message);
              }
            });
        // Special-case FieldMask.
        printers.put(
            FieldMask.getDescriptor().getFullName(),
            new WellKnownTypePrinter() {
              @Override
              public void print(PrinterImpl printer, MessageOrBuilder message) throws IOException {
                printer.printFieldMask(message);
              }
            });
        // Special-case Struct.
        printers.put(
            Struct.getDescriptor().getFullName(),
            new WellKnownTypePrinter() {
              @Override
              public void print(PrinterImpl printer, MessageOrBuilder message) throws IOException {
                printer.printStruct(message);
              }
            });
        // Special-case Value.
        printers.put(
            Value.getDescriptor().getFullName(),
            new WellKnownTypePrinter() {
              @Override
              public void print(PrinterImpl printer, MessageOrBuilder message) throws IOException {
                printer.printValue(message);
              }
            });
        // Special-case ListValue.
        printers.put(
            ListValue.getDescriptor().getFullName(),
            new WellKnownTypePrinter() {
              @Override
              public void print(PrinterImpl printer, MessageOrBuilder message) throws IOException {
                printer.printListValue(message);
              }
            });
        return printers;
      }
  
      /** Prints google.protobuf.Any */
      private void printAny(MessageOrBuilder message) throws IOException {
        if (Any.getDefaultInstance().equals(message)) {
          generator.print("{}");
          return;
        }
        Descriptor descriptor = message.getDescriptorForType();
        FieldDescriptor typeUrlField = descriptor.findFieldByName("type_url");
        FieldDescriptor valueField = descriptor.findFieldByName("value");
        // Validates type of the message. Note that we can't just cast the message
        // to com.google.protobuf.Any because it might be a DynamicMessage.
        if (typeUrlField == null
            || valueField == null
            || typeUrlField.getType() != FieldDescriptor.Type.STRING
            || valueField.getType() != FieldDescriptor.Type.BYTES) {
          throw new InvalidProtocolBufferException("Invalid Any type.");
        }
        String typeUrl = (String) message.getField(typeUrlField);
        String typeName = getTypeName(typeUrl);
        Descriptor type = registry.find(typeName);
        if (type == null) {
          throw new InvalidProtocolBufferException("Cannot find type for url: " + typeUrl);
        }
        ByteString content = (ByteString) message.getField(valueField);
        Message contentMessage =
            DynamicMessage.getDefaultInstance(type).getParserForType().parseFrom(content);
        WellKnownTypePrinter printer = wellKnownTypePrinters.get(typeName);
        if (printer != null) {
          // If the type is one of the well-known types, we use a special
          // formatting.
          generator.print("{" + blankOrNewLine);
          generator.indent();
          generator.print("\"@type\":" + blankOrSpace + gson.toJson(typeUrl) + "," + blankOrNewLine);
          generator.print("\"value\":" + blankOrSpace);
          printer.print(this, contentMessage);
          generator.print(blankOrNewLine);
          generator.outdent();
          generator.print("}");
        } else {
          // Print the content message instead (with a "@type" field added).
          print(contentMessage, typeUrl);
        }
      }
  
      /** Prints wrapper types (e.g., google.protobuf.Int32Value) */
      private void printWrapper(MessageOrBuilder message) throws IOException {
        Descriptor descriptor = message.getDescriptorForType();
        FieldDescriptor valueField = descriptor.findFieldByName("value");
        if (valueField == null) {
          throw new InvalidProtocolBufferException("Invalid Wrapper type.");
        }
        // When formatting wrapper types, we just print its value field instead of
        // the whole message.
        printSingleFieldValue(valueField, message.getField(valueField));
      }
  
      private ByteString toByteString(MessageOrBuilder message) {
        if (message instanceof Message) {
          return ((Message) message).toByteString();
        } else {
          return ((Message.Builder) message).build().toByteString();
        }
      }
  
      /** Prints google.protobuf.Timestamp */
      private void printTimestamp(MessageOrBuilder message) throws IOException {
        Timestamp value = Timestamp.parseFrom(toByteString(message));
        generator.print("\"" + Timestamps.toString(value) + "\"");
      }
  
      /** Prints google.protobuf.Duration */
      private void printDuration(MessageOrBuilder message) throws IOException {
        Duration value = Duration.parseFrom(toByteString(message));
        generator.print("\"" + Durations.toString(value) + "\"");
      }
  
      /** Prints google.protobuf.FieldMask */
      private void printFieldMask(MessageOrBuilder message) throws IOException {
        FieldMask value = FieldMask.parseFrom(toByteString(message));
        generator.print("\"" + FieldMaskUtil.toJsonString(value) + "\"");
      }
  
      /** Prints google.protobuf.Struct */
      private void printStruct(MessageOrBuilder message) throws IOException {
        Descriptor descriptor = message.getDescriptorForType();
        FieldDescriptor field = descriptor.findFieldByName("fields");
        if (field == null) {
          throw new InvalidProtocolBufferException("Invalid Struct type.");
        }
        // Struct is formatted as a map object.
        printMapFieldValue(field, message.getField(field));
      }
  
      /** Prints google.protobuf.Value */
      private void printValue(MessageOrBuilder message) throws IOException {
        // For a Value message, only the value of the field is formatted.
        Map<FieldDescriptor, Object> fields = message.getAllFields();
        if (fields.isEmpty()) {
          // No value set.
          generator.print("null");
          return;
        }
        // A Value message can only have at most one field set (it only contains
        // an oneof).
        if (fields.size() != 1) {
          throw new InvalidProtocolBufferException("Invalid Value type.");
        }
        for (Map.Entry<FieldDescriptor, Object> entry : fields.entrySet()) {
          printSingleFieldValue(entry.getKey(), entry.getValue());
        }
      }
  
      /** Prints google.protobuf.ListValue */
      private void printListValue(MessageOrBuilder message) throws IOException {
        Descriptor descriptor = message.getDescriptorForType();
        FieldDescriptor field = descriptor.findFieldByName("values");
        if (field == null) {
          throw new InvalidProtocolBufferException("Invalid ListValue type.");
        }
        printRepeatedFieldValue(field, message.getField(field));
      }
  
      /** Prints a regular message with an optional type URL. */
      private void print(MessageOrBuilder message, String typeUrl) throws IOException {
        generator.print("{" + blankOrNewLine);
        generator.indent();
  
        boolean printedField = false;
        if (typeUrl != null) {
          generator.print("\"@type\":" + blankOrSpace + gson.toJson(typeUrl));
          printedField = true;
        }
        Map<FieldDescriptor, Object> fieldsToPrint = null;
        if (alwaysOutputDefaultValueFields || !includingDefaultValueFields.isEmpty()) {
          fieldsToPrint = new TreeMap<FieldDescriptor, Object>(message.getAllFields());
          for (FieldDescriptor field : message.getDescriptorForType().getFields()) {
            if (field.isOptional()) {
              if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE
                  && !message.hasField(field)) {
                // Always skip empty optional message fields. If not we will recurse indefinitely if
                // a message has itself as a sub-field.
                continue;
              }
              OneofDescriptor oneof = field.getContainingOneof();
              if (oneof != null && !message.hasField(field)) {
                // Skip all oneof fields except the one that is actually set
                continue;
              }
            }
            if (!fieldsToPrint.containsKey(field)
                && (alwaysOutputDefaultValueFields || includingDefaultValueFields.contains(field))) {
              fieldsToPrint.put(field, message.getField(field));
            }
          }
        } else {
          fieldsToPrint = message.getAllFields();
        }
        for (Map.Entry<FieldDescriptor, Object> field : fieldsToPrint.entrySet()) {
          if (printedField) {
            // Add line-endings for the previous field.
            generator.print("," + blankOrNewLine);
          } else {
            printedField = true;
          }
          printField(field.getKey(), field.getValue());
        }
  
        // Add line-endings for the last field.
        if (printedField) {
          generator.print(blankOrNewLine);
        }
        generator.outdent();
        generator.print("}");
      }
  
      private void printField(FieldDescriptor field, Object value) throws IOException {
        if (preservingProtoFieldNames) {
          generator.print("\"" + field.getName() + "\":" + blankOrSpace);
        } else {
          generator.print("\"" + field.getJsonName() + "\":" + blankOrSpace);
        }
        if (field.isMapField()) {
          printMapFieldValue(field, value);
        } else if (field.isRepeated()) {
          printRepeatedFieldValue(field, value);
        } else {
          printSingleFieldValue(field, value);
        }
      }
  
      @SuppressWarnings("rawtypes")
      private void printRepeatedFieldValue(FieldDescriptor field, Object value) throws IOException {
        generator.print("[");
        boolean printedElement = false;
        for (Object element : (List) value) {
          if (printedElement) {
            generator.print("," + blankOrSpace);
          } else {
            printedElement = true;
          }
          printSingleFieldValue(field, element);
        }
        generator.print("]");
      }
  
      @SuppressWarnings("rawtypes")
      private void printMapFieldValue(FieldDescriptor field, Object value) throws IOException {
        Descriptor type = field.getMessageType();
        FieldDescriptor keyField = type.findFieldByName("key");
        FieldDescriptor valueField = type.findFieldByName("value");
        if (keyField == null || valueField == null) {
          throw new InvalidProtocolBufferException("Invalid map field.");
        }
        generator.print("{" + blankOrNewLine);
        generator.indent();
        boolean printedElement = false;
        for (Object element : (List) value) {
          Message entry = (Message) element;
          Object entryKey = entry.getField(keyField);
          Object entryValue = entry.getField(valueField);
          if (printedElement) {
            generator.print("," + blankOrNewLine);
          } else {
            printedElement = true;
          }
          // Key fields are always double-quoted.
          printSingleFieldValue(keyField, entryKey, true);
          generator.print(":" + blankOrSpace);
          printSingleFieldValue(valueField, entryValue);
        }
        if (printedElement) {
          generator.print(blankOrNewLine);
        }
        generator.outdent();
        generator.print("}");
      }
  
      private void printSingleFieldValue(FieldDescriptor field, Object value) throws IOException {
        printSingleFieldValue(field, value, false);
      }
  
      /**
       * Prints a field's value in JSON format.
       *
       * @param alwaysWithQuotes whether to always add double-quotes to primitive
       *        types.
       */
      private void printSingleFieldValue(
          final FieldDescriptor field, final Object value, boolean alwaysWithQuotes)
          throws IOException {
        switch (field.getType()) {
          case INT32:
          case SINT32:
          case SFIXED32:
            if (alwaysWithQuotes) {
              generator.print("\"");
            }
            generator.print(((Integer) value).toString());
            if (alwaysWithQuotes) {
              generator.print("\"");
            }
            break;
  
          case INT64:
          case SINT64:
          case SFIXED64:
            generator.print("\"" + ((Long) value).toString() + "\"");
            break;
  
          case BOOL:
            if (alwaysWithQuotes) {
              generator.print("\"");
            }
            if (((Boolean) value).booleanValue()) {
              generator.print("true");
            } else {
              generator.print("false");
            }
            if (alwaysWithQuotes) {
              generator.print("\"");
            }
            break;
  
          case FLOAT:
            Float floatValue = (Float) value;
            if (floatValue.isNaN()) {
              generator.print("\"NaN\"");
            } else if (floatValue.isInfinite()) {
              if (floatValue < 0) {
                generator.print("\"-Infinity\"");
              } else {
                generator.print("\"Infinity\"");
              }
            } else {
              if (alwaysWithQuotes) {
                generator.print("\"");
              }
              generator.print(floatValue.toString());
              if (alwaysWithQuotes) {
                generator.print("\"");
              }
            }
            break;
  
          case DOUBLE:
            Double doubleValue = (Double) value;
            if (doubleValue.isNaN()) {
              generator.print("\"NaN\"");
            } else if (doubleValue.isInfinite()) {
              if (doubleValue < 0) {
                generator.print("\"-Infinity\"");
              } else {
                generator.print("\"Infinity\"");
              }
            } else {
              if (alwaysWithQuotes) {
                generator.print("\"");
              }
              generator.print(doubleValue.toString());
              if (alwaysWithQuotes) {
                generator.print("\"");
              }
            }
            break;
  
          case UINT32:
          case FIXED32:
            if (alwaysWithQuotes) {
              generator.print("\"");
            }
            generator.print(unsignedToString((Integer) value));
            if (alwaysWithQuotes) {
              generator.print("\"");
            }
            break;
  
          case UINT64:
          case FIXED64:
            generator.print("\"" + unsignedToString((Long) value) + "\"");
            break;
  
          case STRING:
            generator.print(gson.toJson(value));
            break;
  
          case BYTES:
            generator.print("\"");
            generator.print(BaseEncoding.base64().encode(((ByteString) value).toByteArray()));
            generator.print("\"");
            break;
  
          case ENUM:
            // Special-case google.protobuf.NullValue (it's an Enum).
            if (field.getEnumType().getFullName().equals("google.protobuf.NullValue")) {
              // No matter what value it contains, we always print it as "null".
              if (alwaysWithQuotes) {
                generator.print("\"");
              }
              generator.print("null");
              if (alwaysWithQuotes) {
                generator.print("\"");
              }
            } else {
              if (printingEnumsAsInts || ((EnumValueDescriptor) value).getIndex() == -1) {
                generator.print(String.valueOf(((EnumValueDescriptor) value).getNumber()));
              } else {
                generator.print("\"" + ((EnumValueDescriptor) value).getName() + "\"");
              }
            }
            break;
  
          case MESSAGE:
          case GROUP:
            print((Message) value);
            break;
        }
      }
    }
  
    /** Convert an unsigned 32-bit integer to a string. */
    private static String unsignedToString(final int value) {
      if (value >= 0) {
        return Integer.toString(value);
      } else {
        return Long.toString(value & 0x00000000FFFFFFFFL);
      }
    }
  
    /** Convert an unsigned 64-bit integer to a string. */
    private static String unsignedToString(final long value) {
      if (value >= 0) {
        return Long.toString(value);
      } else {
        // Pull off the most-significant bit so that BigInteger doesn't think
        // the number is negative, then set it again using setBit().
        return BigInteger.valueOf(value & Long.MAX_VALUE).setBit(Long.SIZE - 1).toString();
      }
    }
  
    private static String getTypeName(String typeUrl) throws InvalidProtocolBufferException {
      String[] parts = typeUrl.split("/");
      if (parts.length == 1) {
        throw new InvalidProtocolBufferException("Invalid type url found: " + typeUrl);
      }
      return parts[parts.length - 1];
    }
  
    private static class ParserImpl {
      private final TypeRegistry registry;
      private final JsonParser jsonParser;
      private final boolean ignoringUnknownFields;
      private final int recursionLimit;
      private int currentDepth;
  
      ParserImpl(TypeRegistry registry, boolean ignoreUnknownFields, int recursionLimit) {
        this.registry = registry;
        this.ignoringUnknownFields = ignoreUnknownFields;
        this.jsonParser = new JsonParser();
        this.recursionLimit = recursionLimit;
        this.currentDepth = 0;
      }
  
      void merge(Reader json, Message.Builder builder) throws IOException {
        try {
          JsonReader reader = new JsonReader(json);
          reader.setLenient(false);
          merge(jsonParser.parse(reader), builder);
        } catch (InvalidProtocolBufferException e) {
          throw e;
        } catch (JsonIOException e) {
          // Unwrap IOException.
          if (e.getCause() instanceof IOException) {
            throw (IOException) e.getCause();
          } else {
            throw new InvalidProtocolBufferException(e.getMessage());
          }
        } catch (Exception e) {
          // We convert all exceptions from JSON parsing to our own exceptions.
          throw new InvalidProtocolBufferException(e.getMessage());
        }
      }
  
      void merge(String json, Message.Builder builder) throws InvalidProtocolBufferException {
        try {
          JsonReader reader = new JsonReader(new StringReader(json));
          reader.setLenient(false);
          merge(jsonParser.parse(reader), builder);
        } catch (InvalidProtocolBufferException e) {
          throw e;
        } catch (Exception e) {
          // We convert all exceptions from JSON parsing to our own exceptions.
          throw new InvalidProtocolBufferException(e.getMessage());
        }
      }
  
      private interface WellKnownTypeParser {
        void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
            throws InvalidProtocolBufferException;
      }
  
      private static final Map<String, WellKnownTypeParser> wellKnownTypeParsers =
          buildWellKnownTypeParsers();
  
      private static Map<String, WellKnownTypeParser> buildWellKnownTypeParsers() {
        Map<String, WellKnownTypeParser> parsers = new HashMap<String, WellKnownTypeParser>();
        // Special-case Any.
        parsers.put(
            Any.getDescriptor().getFullName(),
            new WellKnownTypeParser() {
              @Override
              public void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
                  throws InvalidProtocolBufferException {
                parser.mergeAny(json, builder);
              }
            });
        // Special-case wrapper types.
        WellKnownTypeParser wrappersPrinter =
            new WellKnownTypeParser() {
              @Override
              public void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
                  throws InvalidProtocolBufferException {
                parser.mergeWrapper(json, builder);
              }
            };
        parsers.put(BoolValue.getDescriptor().getFullName(), wrappersPrinter);
        parsers.put(Int32Value.getDescriptor().getFullName(), wrappersPrinter);
        parsers.put(UInt32Value.getDescriptor().getFullName(), wrappersPrinter);
        parsers.put(Int64Value.getDescriptor().getFullName(), wrappersPrinter);
        parsers.put(UInt64Value.getDescriptor().getFullName(), wrappersPrinter);
        parsers.put(StringValue.getDescriptor().getFullName(), wrappersPrinter);
        parsers.put(BytesValue.getDescriptor().getFullName(), wrappersPrinter);
        parsers.put(FloatValue.getDescriptor().getFullName(), wrappersPrinter);
        parsers.put(DoubleValue.getDescriptor().getFullName(), wrappersPrinter);
        // Special-case Timestamp.
        parsers.put(
            Timestamp.getDescriptor().getFullName(),
            new WellKnownTypeParser() {
              @Override
              public void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
                  throws InvalidProtocolBufferException {
                parser.mergeTimestamp(json, builder);
              }
            });
        // Special-case Duration.
        parsers.put(
            Duration.getDescriptor().getFullName(),
            new WellKnownTypeParser() {
              @Override
              public void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
                  throws InvalidProtocolBufferException {
                parser.mergeDuration(json, builder);
              }
            });
        // Special-case FieldMask.
        parsers.put(
            FieldMask.getDescriptor().getFullName(),
            new WellKnownTypeParser() {
              @Override
              public void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
                  throws InvalidProtocolBufferException {
                parser.mergeFieldMask(json, builder);
              }
            });
        // Special-case Struct.
        parsers.put(
            Struct.getDescriptor().getFullName(),
            new WellKnownTypeParser() {
              @Override
              public void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
                  throws InvalidProtocolBufferException {
                parser.mergeStruct(json, builder);
              }
            });
        // Special-case ListValue.
        parsers.put(
            ListValue.getDescriptor().getFullName(),
            new WellKnownTypeParser() {
              @Override
              public void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
                  throws InvalidProtocolBufferException {
                parser.mergeListValue(json, builder);
              }
            });
        // Special-case Value.
        parsers.put(
            Value.getDescriptor().getFullName(),
            new WellKnownTypeParser() {
              @Override
              public void merge(ParserImpl parser, JsonElement json, Message.Builder builder)
                  throws InvalidProtocolBufferException {
                parser.mergeValue(json, builder);
              }
            });
        return parsers;
      }
  
      private void merge(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        WellKnownTypeParser specialParser =
            wellKnownTypeParsers.get(builder.getDescriptorForType().getFullName());
        if (specialParser != null) {
          specialParser.merge(this, json, builder);
          return;
        }
        mergeMessage(json, builder, false);
      }
  
      // Maps from camel-case field names to FieldDescriptor.
      private final Map<Descriptor, Map<String, FieldDescriptor>> fieldNameMaps =
          new HashMap<Descriptor, Map<String, FieldDescriptor>>();
  
      private Map<String, FieldDescriptor> getFieldNameMap(Descriptor descriptor) {
        if (!fieldNameMaps.containsKey(descriptor)) {
          Map<String, FieldDescriptor> fieldNameMap = new HashMap<String, FieldDescriptor>();
          for (FieldDescriptor field : descriptor.getFields()) {
            fieldNameMap.put(field.getName(), field);
            fieldNameMap.put(field.getJsonName(), field);
          }
          fieldNameMaps.put(descriptor, fieldNameMap);
          return fieldNameMap;
        }
        return fieldNameMaps.get(descriptor);
      }
  
      private void mergeMessage(JsonElement json, Message.Builder builder, boolean skipTypeUrl)
          throws InvalidProtocolBufferException {
        if (!(json instanceof JsonObject)) {
          throw new InvalidProtocolBufferException("Expect message object but got: " + json);
        }
        JsonObject object = (JsonObject) json;
        Map<String, FieldDescriptor> fieldNameMap = getFieldNameMap(builder.getDescriptorForType());
        for (Map.Entry<String, JsonElement> entry : object.entrySet()) {
          if (skipTypeUrl && entry.getKey().equals("@type")) {
            continue;
          }
          FieldDescriptor field = fieldNameMap.get(entry.getKey());
          if (field == null) {
            if (ignoringUnknownFields) {
              continue;
            }
            throw new InvalidProtocolBufferException(
                "Cannot find field: "
                    + entry.getKey()
                    + " in message "
                    + builder.getDescriptorForType().getFullName());
          }
          mergeField(field, entry.getValue(), builder);
        }
      }
  
      private void mergeAny(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        Descriptor descriptor = builder.getDescriptorForType();
        FieldDescriptor typeUrlField = descriptor.findFieldByName("type_url");
        FieldDescriptor valueField = descriptor.findFieldByName("value");
        // Validates type of the message. Note that we can't just cast the message
        // to com.google.protobuf.Any because it might be a DynamicMessage.
        if (typeUrlField == null
            || valueField == null
            || typeUrlField.getType() != FieldDescriptor.Type.STRING
            || valueField.getType() != FieldDescriptor.Type.BYTES) {
          throw new InvalidProtocolBufferException("Invalid Any type.");
        }
  
        if (!(json instanceof JsonObject)) {
          throw new InvalidProtocolBufferException("Expect message object but got: " + json);
        }
        JsonObject object = (JsonObject) json;
        if (object.entrySet().isEmpty()) {
          return; // builder never modified, so it will end up building the default instance of Any
        }
        JsonElement typeUrlElement = object.get("@type");
        if (typeUrlElement == null) {
          throw new InvalidProtocolBufferException("Missing type url when parsing: " + json);
        }
        String typeUrl = typeUrlElement.getAsString();
        Descriptor contentType = registry.find(getTypeName(typeUrl));
        if (contentType == null) {
          throw new InvalidProtocolBufferException("Cannot resolve type: " + typeUrl);
        }
        builder.setField(typeUrlField, typeUrl);
        Message.Builder contentBuilder =
            DynamicMessage.getDefaultInstance(contentType).newBuilderForType();
        WellKnownTypeParser specialParser = wellKnownTypeParsers.get(contentType.getFullName());
        if (specialParser != null) {
          JsonElement value = object.get("value");
          if (value != null) {
            specialParser.merge(this, value, contentBuilder);
          }
        } else {
          mergeMessage(json, contentBuilder, true);
        }
        builder.setField(valueField, contentBuilder.build().toByteString());
      }
  
      private void mergeFieldMask(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        FieldMask value = FieldMaskUtil.fromJsonString(json.getAsString());
        builder.mergeFrom(value.toByteString());
      }
  
      private void mergeTimestamp(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        try {
          Timestamp value = Timestamps.parse(json.getAsString());
          builder.mergeFrom(value.toByteString());
        } catch (ParseException e) {
          throw new InvalidProtocolBufferException("Failed to parse timestamp: " + json);
        }
      }
  
      private void mergeDuration(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        try {
          Duration value = Durations.parse(json.getAsString());
          builder.mergeFrom(value.toByteString());
        } catch (ParseException e) {
          throw new InvalidProtocolBufferException("Failed to parse duration: " + json);
        }
      }
  
      private void mergeStruct(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        Descriptor descriptor = builder.getDescriptorForType();
        FieldDescriptor field = descriptor.findFieldByName("fields");
        if (field == null) {
          throw new InvalidProtocolBufferException("Invalid Struct type.");
        }
        mergeMapField(field, json, builder);
      }
  
      private void mergeListValue(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        Descriptor descriptor = builder.getDescriptorForType();
        FieldDescriptor field = descriptor.findFieldByName("values");
        if (field == null) {
          throw new InvalidProtocolBufferException("Invalid ListValue type.");
        }
        mergeRepeatedField(field, json, builder);
      }
  
      private void mergeValue(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        Descriptor type = builder.getDescriptorForType();
        if (json instanceof JsonPrimitive) {
          JsonPrimitive primitive = (JsonPrimitive) json;
          if (primitive.isBoolean()) {
            builder.setField(type.findFieldByName("bool_value"), primitive.getAsBoolean());
          } else if (primitive.isNumber()) {
            builder.setField(type.findFieldByName("number_value"), primitive.getAsDouble());
          } else {
            builder.setField(type.findFieldByName("string_value"), primitive.getAsString());
          }
        } else if (json instanceof JsonObject) {
          FieldDescriptor field = type.findFieldByName("struct_value");
          Message.Builder structBuilder = builder.newBuilderForField(field);
          merge(json, structBuilder);
          builder.setField(field, structBuilder.build());
        } else if (json instanceof JsonArray) {
          FieldDescriptor field = type.findFieldByName("list_value");
          Message.Builder listBuilder = builder.newBuilderForField(field);
          merge(json, listBuilder);
          builder.setField(field, listBuilder.build());
        } else if (json instanceof JsonNull) {
          builder.setField(
              type.findFieldByName("null_value"), NullValue.NULL_VALUE.getValueDescriptor());
        } else {
          throw new IllegalStateException("Unexpected json data: " + json);
        }
      }
  
      private void mergeWrapper(JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        Descriptor type = builder.getDescriptorForType();
        FieldDescriptor field = type.findFieldByName("value");
        if (field == null) {
          throw new InvalidProtocolBufferException("Invalid wrapper type: " + type.getFullName());
        }
        builder.setField(field, parseFieldValue(field, json, builder));
      }
  
      private void mergeField(FieldDescriptor field, JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        if (field.isRepeated()) {
          if (builder.getRepeatedFieldCount(field) > 0) {
            throw new InvalidProtocolBufferException(
                "Field " + field.getFullName() + " has already been set.");
          }
        } else {
          if (builder.hasField(field)) {
            throw new InvalidProtocolBufferException(
                "Field " + field.getFullName() + " has already been set.");
          }
          if (field.getContainingOneof() != null
              && builder.getOneofFieldDescriptor(field.getContainingOneof()) != null) {
            FieldDescriptor other = builder.getOneofFieldDescriptor(field.getContainingOneof());
            throw new InvalidProtocolBufferException(
                "Cannot set field "
                    + field.getFullName()
                    + " because another field "
                    + other.getFullName()
                    + " belonging to the same oneof has already been set ");
          }
        }
        if (field.isRepeated() && json instanceof JsonNull) {
          // We allow "null" as value for all field types and treat it as if the
          // field is not present.
          return;
        }
        if (field.isMapField()) {
          mergeMapField(field, json, builder);
        } else if (field.isRepeated()) {
          mergeRepeatedField(field, json, builder);
        } else {
          Object value = parseFieldValue(field, json, builder);
          if (value != null) {
            builder.setField(field, value);
          }
        }
      }
  
      private void mergeMapField(FieldDescriptor field, JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        if (!(json instanceof JsonObject)) {
          throw new InvalidProtocolBufferException("Expect a map object but found: " + json);
        }
        Descriptor type = field.getMessageType();
        FieldDescriptor keyField = type.findFieldByName("key");
        FieldDescriptor valueField = type.findFieldByName("value");
        if (keyField == null || valueField == null) {
          throw new InvalidProtocolBufferException("Invalid map field: " + field.getFullName());
        }
        JsonObject object = (JsonObject) json;
        for (Map.Entry<String, JsonElement> entry : object.entrySet()) {
          Message.Builder entryBuilder = builder.newBuilderForField(field);
          Object key = parseFieldValue(keyField, new JsonPrimitive(entry.getKey()), entryBuilder);
          Object value = parseFieldValue(valueField, entry.getValue(), entryBuilder);
          if (value == null) {
            throw new InvalidProtocolBufferException("Map value cannot be null.");
          }
          entryBuilder.setField(keyField, key);
          entryBuilder.setField(valueField, value);
          builder.addRepeatedField(field, entryBuilder.build());
        }
      }
  
      private void mergeRepeatedField(
          FieldDescriptor field, JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        if (!(json instanceof JsonArray)) {
          throw new InvalidProtocolBufferException("Expect an array but found: " + json);
        }
        JsonArray array = (JsonArray) json;
        for (int i = 0; i < array.size(); ++i) {
          Object value = parseFieldValue(field, array.get(i), builder);
          if (value == null) {
            throw new InvalidProtocolBufferException(
                "Repeated field elements cannot be null in field: " + field.getFullName());
          }
          builder.addRepeatedField(field, value);
        }
      }
  
      private int parseInt32(JsonElement json) throws InvalidProtocolBufferException {
        try {
          return Integer.parseInt(json.getAsString());
        } catch (Exception e) {
          // Fall through.
        }
        // JSON doesn't distinguish between integer values and floating point values so "1" and
        // "1.000" are treated as equal in JSON. For this reason we accept floating point values for
        // integer fields as well as long as it actually is an integer (i.e., round(value) == value).
        try {
          BigDecimal value = new BigDecimal(json.getAsString());
          return value.intValueExact();
        } catch (Exception e) {
          throw new InvalidProtocolBufferException("Not an int32 value: " + json);
        }
      }
  
      private long parseInt64(JsonElement json) throws InvalidProtocolBufferException {
        try {
          return Long.parseLong(json.getAsString());
        } catch (Exception e) {
          // Fall through.
        }
        // JSON doesn't distinguish between integer values and floating point values so "1" and
        // "1.000" are treated as equal in JSON. For this reason we accept floating point values for
        // integer fields as well as long as it actually is an integer (i.e., round(value) == value).
        try {
          BigDecimal value = new BigDecimal(json.getAsString());
          return value.longValueExact();
        } catch (Exception e) {
          throw new InvalidProtocolBufferException("Not an int64 value: " + json);
        }
      }
  
      private int parseUint32(JsonElement json) throws InvalidProtocolBufferException {
        try {
          long result = Long.parseLong(json.getAsString());
          if (result < 0 || result > 0xFFFFFFFFL) {
            throw new InvalidProtocolBufferException("Out of range uint32 value: " + json);
          }
          return (int) result;
        } catch (InvalidProtocolBufferException e) {
          throw e;
        } catch (Exception e) {
          // Fall through.
        }
        // JSON doesn't distinguish between integer values and floating point values so "1" and
        // "1.000" are treated as equal in JSON. For this reason we accept floating point values for
        // integer fields as well as long as it actually is an integer (i.e., round(value) == value).
        try {
          BigDecimal decimalValue = new BigDecimal(json.getAsString());
          BigInteger value = decimalValue.toBigIntegerExact();
          if (value.signum() < 0 || value.compareTo(new BigInteger("FFFFFFFF", 16)) > 0) {
            throw new InvalidProtocolBufferException("Out of range uint32 value: " + json);
          }
          return value.intValue();
        } catch (InvalidProtocolBufferException e) {
          throw e;
        } catch (Exception e) {
          throw new InvalidProtocolBufferException("Not an uint32 value: " + json);
        }
      }
  
      private static final BigInteger MAX_UINT64 = new BigInteger("FFFFFFFFFFFFFFFF", 16);
  
      private long parseUint64(JsonElement json) throws InvalidProtocolBufferException {
        try {
          BigDecimal decimalValue = new BigDecimal(json.getAsString());
          BigInteger value = decimalValue.toBigIntegerExact();
          if (value.compareTo(BigInteger.ZERO) < 0 || value.compareTo(MAX_UINT64) > 0) {
            throw new InvalidProtocolBufferException("Out of range uint64 value: " + json);
          }
          return value.longValue();
        } catch (InvalidProtocolBufferException e) {
          throw e;
        } catch (Exception e) {
          throw new InvalidProtocolBufferException("Not an uint64 value: " + json);
        }
      }
  
      private boolean parseBool(JsonElement json) throws InvalidProtocolBufferException {
        if (json.getAsString().equals("true")) {
          return true;
        }
        if (json.getAsString().equals("false")) {
          return false;
        }
        throw new InvalidProtocolBufferException("Invalid bool value: " + json);
      }
  
      private static final double EPSILON = 1e-6;
  
      private float parseFloat(JsonElement json) throws InvalidProtocolBufferException {
        if (json.getAsString().equals("NaN")) {
          return Float.NaN;
        } else if (json.getAsString().equals("Infinity")) {
          return Float.POSITIVE_INFINITY;
        } else if (json.getAsString().equals("-Infinity")) {
          return Float.NEGATIVE_INFINITY;
        }
        try {
          // We don't use Float.parseFloat() here because that function simply
          // accepts all double values. Here we parse the value into a Double
          // and do explicit range check on it.
          double value = Double.parseDouble(json.getAsString());
          // When a float value is printed, the printed value might be a little
          // larger or smaller due to precision loss. Here we need to add a bit
          // of tolerance when checking whether the float value is in range.
          if (value > Float.MAX_VALUE * (1.0 + EPSILON)
              || value < -Float.MAX_VALUE * (1.0 + EPSILON)) {
            throw new InvalidProtocolBufferException("Out of range float value: " + json);
          }
          return (float) value;
        } catch (InvalidProtocolBufferException e) {
          throw e;
        } catch (Exception e) {
          throw new InvalidProtocolBufferException("Not a float value: " + json);
        }
      }
  
      private static final BigDecimal MORE_THAN_ONE = new BigDecimal(String.valueOf(1.0 + EPSILON));
      // When a float value is printed, the printed value might be a little
      // larger or smaller due to precision loss. Here we need to add a bit
      // of tolerance when checking whether the float value is in range.
      private static final BigDecimal MAX_DOUBLE =
          new BigDecimal(String.valueOf(Double.MAX_VALUE)).multiply(MORE_THAN_ONE);
      private static final BigDecimal MIN_DOUBLE =
          new BigDecimal(String.valueOf(-Double.MAX_VALUE)).multiply(MORE_THAN_ONE);
  
      private double parseDouble(JsonElement json) throws InvalidProtocolBufferException {
        if (json.getAsString().equals("NaN")) {
          return Double.NaN;
        } else if (json.getAsString().equals("Infinity")) {
          return Double.POSITIVE_INFINITY;
        } else if (json.getAsString().equals("-Infinity")) {
          return Double.NEGATIVE_INFINITY;
        }
        try {
          // We don't use Double.parseDouble() here because that function simply
          // accepts all values. Here we parse the value into a BigDecimal and do
          // explicit range check on it.
          BigDecimal value = new BigDecimal(json.getAsString());
          if (value.compareTo(MAX_DOUBLE) > 0 || value.compareTo(MIN_DOUBLE) < 0) {
            throw new InvalidProtocolBufferException("Out of range double value: " + json);
          }
          return value.doubleValue();
        } catch (InvalidProtocolBufferException e) {
          throw e;
        } catch (Exception e) {
          throw new InvalidProtocolBufferException("Not an double value: " + json);
        }
      }
  
      private String parseString(JsonElement json) {
        return json.getAsString();
      }
  
      private ByteString parseBytes(JsonElement json) throws InvalidProtocolBufferException {
        try {
          return ByteString.copyFrom(BaseEncoding.base64().decode(json.getAsString()));
        } catch (IllegalArgumentException e) {
          return ByteString.copyFrom(BaseEncoding.base64Url().decode(json.getAsString()));
        }
      }
  
      private EnumValueDescriptor parseEnum(EnumDescriptor enumDescriptor, JsonElement json)
          throws InvalidProtocolBufferException {
        String value = json.getAsString();
        EnumValueDescriptor result = enumDescriptor.findValueByName(value);
        if (result == null) {
          // Try to interpret the value as a number.
          try {
            int numericValue = parseInt32(json);
            if (enumDescriptor.getFile().getSyntax() == FileDescriptor.Syntax.PROTO3) {
              result = enumDescriptor.findValueByNumberCreatingIfUnknown(numericValue);
            } else {
              result = enumDescriptor.findValueByNumber(numericValue);
            }
          } catch (InvalidProtocolBufferException e) {
            // Fall through. This exception is about invalid int32 value we get from parseInt32() but
            // that's not the exception we want the user to see. Since result == null, we will throw
            // an exception later.
          }
  
          if (result == null) {
            throw new InvalidProtocolBufferException(
                "Invalid enum value: " + value + " for enum type: " + enumDescriptor.getFullName());
          }
        }
        return result;
      }
  
      private Object parseFieldValue(FieldDescriptor field, JsonElement json, Message.Builder builder)
          throws InvalidProtocolBufferException {
        if (json instanceof JsonNull) {
          if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE
              && field.getMessageType().getFullName().equals(Value.getDescriptor().getFullName())) {
            // For every other type, "null" means absence, but for the special
            // Value message, it means the "null_value" field has been set.
            Value value = Value.newBuilder().setNullValueValue(0).build();
            return builder.newBuilderForField(field).mergeFrom(value.toByteString()).build();
          } else if (field.getJavaType() == FieldDescriptor.JavaType.ENUM
              && field.getEnumType().getFullName().equals(NullValue.getDescriptor().getFullName())) {
            // If the type of the field is a NullValue, then the value should be explicitly set.
            return field.getEnumType().findValueByNumber(0);
          }
          return null;
        }
        switch (field.getType()) {
          case INT32:
          case SINT32:
          case SFIXED32:
            return parseInt32(json);
  
          case INT64:
          case SINT64:
          case SFIXED64:
            return parseInt64(json);
  
          case BOOL:
            return parseBool(json);
  
          case FLOAT:
            return parseFloat(json);
  
          case DOUBLE:
            return parseDouble(json);
  
          case UINT32:
          case FIXED32:
            return parseUint32(json);
  
          case UINT64:
          case FIXED64:
            return parseUint64(json);
  
          case STRING:
            return parseString(json);
  
          case BYTES:
            return parseBytes(json);
  
          case ENUM:
            return parseEnum(field.getEnumType(), json);
  
          case MESSAGE:
          case GROUP:
            if (currentDepth >= recursionLimit) {
              throw new InvalidProtocolBufferException("Hit recursion limit.");
            }
            ++currentDepth;
            Message.Builder subBuilder = builder.newBuilderForField(field);
            merge(json, subBuilder);
            --currentDepth;
            return subBuilder.build();
  
          default:
            throw new InvalidProtocolBufferException("Invalid field type: " + field.getType());
        }
      }
    }
  }
  