json.cc

// Copyright 2024 Google LLC
//
// 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
//
//     https://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.

#include "internal/json.h"

#include <cmath>
#include <cstdint>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

#include "google/protobuf/duration.pb.h"
#include "google/protobuf/struct.pb.h"
#include "google/protobuf/timestamp.pb.h"
#include "absl/base/attributes.h"
#include "absl/base/no_destructor.h"
#include "absl/base/nullability.h"
#include "absl/base/optimization.h"
#include "absl/functional/overload.h"
#include "absl/log/absl_check.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/ascii.h"
#include "absl/strings/cord.h"
#include "absl/strings/escaping.h"
#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
#include "absl/types/variant.h"
#include "extensions/protobuf/internal/map_reflection.h"
#include "internal/status_macros.h"
#include "internal/strings.h"
#include "internal/well_known_types.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/map_field.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/util/time_util.h"

#undef GetMessage

namespace cel::internal {

namespace {

using ::cel::well_known_types::AsVariant;
using ::cel::well_known_types::GetListValueReflection;
using ::cel::well_known_types::GetRepeatedBytesField;
using ::cel::well_known_types::GetRepeatedStringField;
using ::cel::well_known_types::GetStructReflection;
using ::cel::well_known_types::GetValueReflection;
using ::cel::well_known_types::JsonReflection;
using ::cel::well_known_types::ListValueReflection;
using ::cel::well_known_types::Reflection;
using ::cel::well_known_types::StructReflection;
using ::cel::well_known_types::ValueReflection;
using ::google::protobuf::Descriptor;
using ::google::protobuf::FieldDescriptor;
using ::google::protobuf::util::TimeUtil;

// Yanked from the implementation `google::protobuf::util::TimeUtil`.
template <typename Chars>
absl::Status SnakeCaseToCamelCaseImpl(Chars input,
                                      std::string* absl_nonnull output) {
  output->clear();
  bool after_underscore = false;
  for (char input_char : input) {
    if (absl::ascii_isupper(input_char)) {
      // The field name must not contain uppercase letters.
      return absl::InvalidArgumentError(
          "field mask path name contains uppercase letters");
    }
    if (after_underscore) {
      if (absl::ascii_islower(input_char)) {
        output->push_back(absl::ascii_toupper(input_char));
        after_underscore = false;
      } else {
        // The character after a "_" must be a lowercase letter.
        return absl::InvalidArgumentError(
            "field mask path contains '_' not followed by a lowercase letter");
      }
    } else if (input_char == '_') {
      after_underscore = true;
    } else {
      output->push_back(input_char);
    }
  }
  if (after_underscore) {
    // Trailing "_".
    return absl::InvalidArgumentError("field mask path contains trailing '_'");
  }
  return absl::OkStatus();
}

absl::Status SnakeCaseToCamelCase(const well_known_types::StringValue& input,
                                  std::string* absl_nonnull output) {
  return absl::visit(absl::Overload(
                         [&](absl::string_view string) -> absl::Status {
                           return SnakeCaseToCamelCaseImpl(string, output);
                         },
                         [&](const absl::Cord& cord) -> absl::Status {
                           return SnakeCaseToCamelCaseImpl(cord.Chars(),
                                                           output);
                         }),
                     AsVariant(input));
}

class MessageToJsonState;

using MapFieldKeyToString = std::string (*)(const google::protobuf::MapKey&);

std::string BoolMapFieldKeyToString(const google::protobuf::MapKey& key) {
  return key.GetBoolValue() ? "true" : "false";
}

std::string Int32MapFieldKeyToString(const google::protobuf::MapKey& key) {
  return absl::StrCat(key.GetInt32Value());
}

std::string Int64MapFieldKeyToString(const google::protobuf::MapKey& key) {
  return absl::StrCat(key.GetInt64Value());
}

std::string UInt32MapFieldKeyToString(const google::protobuf::MapKey& key) {
  return absl::StrCat(key.GetUInt32Value());
}

std::string UInt64MapFieldKeyToString(const google::protobuf::MapKey& key) {
  return absl::StrCat(key.GetUInt64Value());
}

std::string StringMapFieldKeyToString(const google::protobuf::MapKey& key) {
  return std::string(key.GetStringValue());
}

MapFieldKeyToString GetMapFieldKeyToString(
    const google::protobuf::FieldDescriptor* absl_nonnull field) {
  switch (field->cpp_type()) {
    case FieldDescriptor::CPPTYPE_BOOL:
      return &BoolMapFieldKeyToString;
    case FieldDescriptor::CPPTYPE_INT32:
      return &Int32MapFieldKeyToString;
    case FieldDescriptor::CPPTYPE_INT64:
      return &Int64MapFieldKeyToString;
    case FieldDescriptor::CPPTYPE_UINT32:
      return &UInt32MapFieldKeyToString;
    case FieldDescriptor::CPPTYPE_UINT64:
      return &UInt64MapFieldKeyToString;
    case FieldDescriptor::CPPTYPE_STRING:
      return &StringMapFieldKeyToString;
    default:
      ABSL_UNREACHABLE();
  }
}

using MapFieldValueToValue = absl::Status (MessageToJsonState::*)(
    const google::protobuf::MapValueConstRef& value,
    const google::protobuf::FieldDescriptor* absl_nonnull field,
    google::protobuf::MessageLite* absl_nonnull result);

using RepeatedFieldToValue = absl::Status (MessageToJsonState::*)(
    const google::protobuf::Reflection* absl_nonnull reflection,
    const google::protobuf::Message& message,
    const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
    google::protobuf::MessageLite* absl_nonnull result);

class MessageToJsonState {
 public:
  MessageToJsonState(const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
                     google::protobuf::MessageFactory* absl_nonnull message_factory)
      : descriptor_pool_(descriptor_pool), message_factory_(message_factory) {}

  virtual ~MessageToJsonState() = default;

  absl::Status ToJson(const google::protobuf::Message& message,
                      google::protobuf::MessageLite* absl_nonnull result) {
    const auto* descriptor = message.GetDescriptor();
    switch (descriptor->well_known_type()) {
      case Descriptor::WELLKNOWNTYPE_DOUBLEVALUE: {
        CEL_RETURN_IF_ERROR(reflection_.DoubleValue().Initialize(descriptor));
        SetNumberValue(result, reflection_.DoubleValue().GetValue(message));
      } break;
      case Descriptor::WELLKNOWNTYPE_FLOATVALUE: {
        CEL_RETURN_IF_ERROR(reflection_.FloatValue().Initialize(descriptor));
        SetNumberValue(result, reflection_.FloatValue().GetValue(message));
      } break;
      case Descriptor::WELLKNOWNTYPE_INT64VALUE: {
        CEL_RETURN_IF_ERROR(reflection_.Int64Value().Initialize(descriptor));
        SetNumberValue(result, reflection_.Int64Value().GetValue(message));
      } break;
      case Descriptor::WELLKNOWNTYPE_UINT64VALUE: {
        CEL_RETURN_IF_ERROR(reflection_.UInt64Value().Initialize(descriptor));
        SetNumberValue(result, reflection_.UInt64Value().GetValue(message));
      } break;
      case Descriptor::WELLKNOWNTYPE_INT32VALUE: {
        CEL_RETURN_IF_ERROR(reflection_.Int32Value().Initialize(descriptor));
        SetNumberValue(result, reflection_.Int32Value().GetValue(message));
      } break;
      case Descriptor::WELLKNOWNTYPE_UINT32VALUE: {
        CEL_RETURN_IF_ERROR(reflection_.UInt32Value().Initialize(descriptor));
        SetNumberValue(result, reflection_.UInt32Value().GetValue(message));
      } break;
      case Descriptor::WELLKNOWNTYPE_STRINGVALUE: {
        CEL_RETURN_IF_ERROR(reflection_.StringValue().Initialize(descriptor));
        StringValueToJson(reflection_.StringValue().GetValue(message, scratch_),
                          result);
      } break;
      case Descriptor::WELLKNOWNTYPE_BYTESVALUE: {
        CEL_RETURN_IF_ERROR(reflection_.BytesValue().Initialize(descriptor));
        BytesValueToJson(reflection_.BytesValue().GetValue(message, scratch_),
                         result);
      } break;
      case Descriptor::WELLKNOWNTYPE_BOOLVALUE: {
        CEL_RETURN_IF_ERROR(reflection_.BoolValue().Initialize(descriptor));
        SetBoolValue(result, reflection_.BoolValue().GetValue(message));
      } break;
      case Descriptor::WELLKNOWNTYPE_ANY: {
        CEL_ASSIGN_OR_RETURN(auto unpacked,
                             well_known_types::UnpackAnyFrom(
                                 result->GetArena(), reflection_.Any(), message,
                                 descriptor_pool_, message_factory_));
        auto* struct_result = MutableStructValue(result);
        const auto* unpacked_descriptor = unpacked->GetDescriptor();
        SetStringValue(InsertField(struct_result, "@type"),
                       absl::StrCat("type.googleapis.com/",
                                    unpacked_descriptor->full_name()));
        switch (unpacked_descriptor->well_known_type()) {
          case Descriptor::WELLKNOWNTYPE_DOUBLEVALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_FLOATVALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_INT64VALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_UINT64VALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_INT32VALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_UINT32VALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_STRINGVALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_BYTESVALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_BOOLVALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_FIELDMASK:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_DURATION:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_TIMESTAMP:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_VALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_LISTVALUE:
            ABSL_FALLTHROUGH_INTENDED;
          case Descriptor::WELLKNOWNTYPE_STRUCT:
            return ToJson(*unpacked, InsertField(struct_result, "value"));
          default:
            if (unpacked_descriptor->full_name() == "google.protobuf.Empty") {
              MutableStructValue(InsertField(struct_result, "value"));
              return absl::OkStatus();
            } else {
              return MessageToJson(*unpacked, struct_result);
            }
        }
      }
      case Descriptor::WELLKNOWNTYPE_FIELDMASK: {
        CEL_RETURN_IF_ERROR(reflection_.FieldMask().Initialize(descriptor));
        std::vector<std::string> paths;
        const int paths_size = reflection_.FieldMask().PathsSize(message);
        for (int i = 0; i < paths_size; ++i) {
          CEL_RETURN_IF_ERROR(SnakeCaseToCamelCase(
              reflection_.FieldMask().Paths(message, i, scratch_),
              &paths.emplace_back()));
        }
        SetStringValue(result, absl::StrJoin(paths, ","));
      } break;
      case Descriptor::WELLKNOWNTYPE_DURATION: {
        CEL_RETURN_IF_ERROR(reflection_.Duration().Initialize(descriptor));
        google::protobuf::Duration duration;
        duration.set_seconds(reflection_.Duration().GetSeconds(message));
        duration.set_nanos(reflection_.Duration().GetNanos(message));
        SetStringValue(result, TimeUtil::ToString(duration));
      } break;
      case Descriptor::WELLKNOWNTYPE_TIMESTAMP: {
        CEL_RETURN_IF_ERROR(reflection_.Timestamp().Initialize(descriptor));
        google::protobuf::Timestamp timestamp;
        timestamp.set_seconds(reflection_.Timestamp().GetSeconds(message));
        timestamp.set_nanos(reflection_.Timestamp().GetNanos(message));
        SetStringValue(result, TimeUtil::ToString(timestamp));
      } break;
      case Descriptor::WELLKNOWNTYPE_VALUE: {
        absl::Cord serialized;
        if (!message.SerializePartialToString(&serialized)) {
          return absl::UnknownError(
              "failed to serialize message google.protobuf.Value");
        }
        if (!result->ParsePartialFromString(serialized)) {
          return absl::UnknownError(
              "failed to parsed message: google.protobuf.Value");
        }
      } break;
      case Descriptor::WELLKNOWNTYPE_LISTVALUE: {
        absl::Cord serialized;
        if (!message.SerializePartialToString(&serialized)) {
          return absl::UnknownError(
              "failed to serialize message google.protobuf.ListValue");
        }
        if (!MutableListValue(result)->ParsePartialFromString(serialized)) {
          return absl::UnknownError(
              "failed to parsed message: google.protobuf.ListValue");
        }
      } break;
      case Descriptor::WELLKNOWNTYPE_STRUCT: {
        absl::Cord serialized;
        if (!message.SerializePartialToString(&serialized)) {
          return absl::UnknownError(
              "failed to serialize message google.protobuf.Struct");
        }
        if (!MutableStructValue(result)->ParsePartialFromString(serialized)) {
          return absl::UnknownError(
              "failed to parsed message: google.protobuf.Struct");
        }
      } break;
      default:
        return MessageToJson(message, MutableStructValue(result));
    }
    return absl::OkStatus();
  }

  absl::Status ToJsonObject(const google::protobuf::Message& message,
                            google::protobuf::MessageLite* absl_nonnull result) {
    return MessageToJson(message, result);
  }

  absl::Status FieldToJson(const google::protobuf::Message& message,
                           const google::protobuf::FieldDescriptor* absl_nonnull field,
                           google::protobuf::MessageLite* absl_nonnull result) {
    return MessageFieldToJson(message, field, result);
  }

  absl::Status FieldToJsonArray(
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    return MessageRepeatedFieldToJson(message, field, result);
  }

  absl::Status FieldToJsonObject(
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    return MessageMapFieldToJson(message, field, result);
  }

  virtual absl::Status Initialize(
      google::protobuf::MessageLite* absl_nonnull message) = 0;

 private:
  absl::StatusOr<MapFieldValueToValue> GetMapFieldValueToValue(
      const google::protobuf::FieldDescriptor* absl_nonnull field) {
    switch (field->type()) {
      case FieldDescriptor::TYPE_DOUBLE:
        return &MessageToJsonState::MapDoubleFieldToValue;
      case FieldDescriptor::TYPE_FLOAT:
        return &MessageToJsonState::MapFloatFieldToValue;
      case FieldDescriptor::TYPE_FIXED64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_UINT64:
        return &MessageToJsonState::MapUInt64FieldToValue;
      case FieldDescriptor::TYPE_BOOL:
        return &MessageToJsonState::MapBoolFieldToValue;
      case FieldDescriptor::TYPE_STRING:
        return &MessageToJsonState::MapStringFieldToValue;
      case FieldDescriptor::TYPE_GROUP:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_MESSAGE:
        return &MessageToJsonState::MapMessageFieldToValue;
      case FieldDescriptor::TYPE_BYTES:
        return &MessageToJsonState::MapBytesFieldToValue;
      case FieldDescriptor::TYPE_FIXED32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_UINT32:
        return &MessageToJsonState::MapUInt32FieldToValue;
      case FieldDescriptor::TYPE_ENUM: {
        const auto* enum_descriptor = field->enum_type();
        if (enum_descriptor->full_name() == "google.protobuf.NullValue") {
          return &MessageToJsonState::MapNullFieldToValue;
        } else {
          return &MessageToJsonState::MapEnumFieldToValue;
        }
      }
      case FieldDescriptor::TYPE_SFIXED32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_SINT32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_INT32:
        return &MessageToJsonState::MapInt32FieldToValue;
      case FieldDescriptor::TYPE_SFIXED64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_SINT64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_INT64:
        return &MessageToJsonState::MapInt64FieldToValue;
      default:
        return absl::InvalidArgumentError(absl::StrCat(
            "unexpected message field type: ", field->type_name()));
    }
  }

  absl::Status MapBoolFieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_BOOL);
    SetBoolValue(result, value.GetBoolValue());
    return absl::OkStatus();
  }

  absl::Status MapInt32FieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_INT32);
    SetNumberValue(result, value.GetInt32Value());
    return absl::OkStatus();
  }

  absl::Status MapInt64FieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_INT64);
    SetNumberValue(result, value.GetInt64Value());
    return absl::OkStatus();
  }

  absl::Status MapUInt32FieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_UINT32);
    SetNumberValue(result, value.GetUInt32Value());
    return absl::OkStatus();
  }

  absl::Status MapUInt64FieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_UINT64);
    SetNumberValue(result, value.GetUInt64Value());
    return absl::OkStatus();
  }

  absl::Status MapFloatFieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_FLOAT);
    SetNumberValue(result, value.GetFloatValue());
    return absl::OkStatus();
  }

  absl::Status MapDoubleFieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_DOUBLE);
    SetNumberValue(result, value.GetDoubleValue());
    return absl::OkStatus();
  }

  absl::Status MapBytesFieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_BYTES);
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_STRING);
    SetStringValueFromBytes(result, value.GetStringValue());
    return absl::OkStatus();
  }

  absl::Status MapStringFieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_STRING);
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_STRING);
    SetStringValue(result, value.GetStringValue());
    return absl::OkStatus();
  }

  absl::Status MapMessageFieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_MESSAGE);
    return ToJson(value.GetMessageValue(), result);
  }

  absl::Status MapEnumFieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_ENUM);
    ABSL_DCHECK_NE(field->enum_type()->full_name(),
                   "google.protobuf.NullValue");
    if (const auto* value_descriptor =
            field->enum_type()->FindValueByNumber(value.GetEnumValue());
        value_descriptor != nullptr) {
      SetStringValue(result, value_descriptor->name());
    } else {
      SetNumberValue(result, value.GetEnumValue());
    }
    return absl::OkStatus();
  }

  absl::Status MapNullFieldToValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
    ABSL_DCHECK(!field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_ENUM);
    ABSL_DCHECK_EQ(field->enum_type()->full_name(),
                   "google.protobuf.NullValue");
    SetNullValue(result);
    return absl::OkStatus();
  }

  absl::StatusOr<RepeatedFieldToValue> GetRepeatedFieldToValue(
      const google::protobuf::FieldDescriptor* absl_nonnull field) {
    switch (field->type()) {
      case FieldDescriptor::TYPE_DOUBLE:
        return &MessageToJsonState::RepeatedDoubleFieldToValue;
      case FieldDescriptor::TYPE_FLOAT:
        return &MessageToJsonState::RepeatedFloatFieldToValue;
      case FieldDescriptor::TYPE_FIXED64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_UINT64:
        return &MessageToJsonState::RepeatedUInt64FieldToValue;
      case FieldDescriptor::TYPE_BOOL:
        return &MessageToJsonState::RepeatedBoolFieldToValue;
      case FieldDescriptor::TYPE_STRING:
        return &MessageToJsonState::RepeatedStringFieldToValue;
      case FieldDescriptor::TYPE_GROUP:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_MESSAGE:
        return &MessageToJsonState::RepeatedMessageFieldToValue;
      case FieldDescriptor::TYPE_BYTES:
        return &MessageToJsonState::RepeatedBytesFieldToValue;
      case FieldDescriptor::TYPE_FIXED32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_UINT32:
        return &MessageToJsonState::RepeatedUInt32FieldToValue;
      case FieldDescriptor::TYPE_ENUM: {
        const auto* enum_descriptor = field->enum_type();
        if (enum_descriptor->full_name() == "google.protobuf.NullValue") {
          return &MessageToJsonState::RepeatedNullFieldToValue;
        } else {
          return &MessageToJsonState::RepeatedEnumFieldToValue;
        }
      }
      case FieldDescriptor::TYPE_SFIXED32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_SINT32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_INT32:
        return &MessageToJsonState::RepeatedInt32FieldToValue;
      case FieldDescriptor::TYPE_SFIXED64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_SINT64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_INT64:
        return &MessageToJsonState::RepeatedInt64FieldToValue;
      default:
        return absl::InvalidArgumentError(absl::StrCat(
            "unexpected message field type: ", field->type_name()));
    }
  }

  absl::Status RepeatedBoolFieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_BOOL);
    SetBoolValue(result, reflection->GetRepeatedBool(message, field, index));
    return absl::OkStatus();
  }

  absl::Status RepeatedInt32FieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_INT32);
    SetNumberValue(result, reflection->GetRepeatedInt32(message, field, index));
    return absl::OkStatus();
  }

  absl::Status RepeatedInt64FieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_INT64);
    SetNumberValue(result, reflection->GetRepeatedInt64(message, field, index));
    return absl::OkStatus();
  }

  absl::Status RepeatedUInt32FieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_UINT32);
    SetNumberValue(result,
                   reflection->GetRepeatedUInt32(message, field, index));
    return absl::OkStatus();
  }

  absl::Status RepeatedUInt64FieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_UINT64);
    SetNumberValue(result,
                   reflection->GetRepeatedUInt64(message, field, index));
    return absl::OkStatus();
  }

  absl::Status RepeatedFloatFieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_FLOAT);
    SetNumberValue(result, reflection->GetRepeatedFloat(message, field, index));
    return absl::OkStatus();
  }

  absl::Status RepeatedDoubleFieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_DOUBLE);
    SetNumberValue(result,
                   reflection->GetRepeatedDouble(message, field, index));
    return absl::OkStatus();
  }

  absl::Status RepeatedBytesFieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_BYTES);
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_STRING);
    absl::visit(absl::Overload(
                    [&](absl::string_view string) -> void {
                      SetStringValueFromBytes(result, string);
                    },
                    [&](absl::Cord&& cord) -> void {
                      SetStringValueFromBytes(result, cord);
                    }),
                AsVariant(GetRepeatedBytesField(reflection, message, field,
                                                index, scratch_)));
    return absl::OkStatus();
  }

  absl::Status RepeatedStringFieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_STRING);
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_STRING);
    absl::visit(
        absl::Overload(
            [&](absl::string_view string) -> void {
              SetStringValue(result, string);
            },
            [&](absl::Cord&& cord) -> void { SetStringValue(result, cord); }),
        AsVariant(GetRepeatedStringField(reflection, message, field, index,
                                         scratch_)));
    return absl::OkStatus();
  }

  absl::Status RepeatedMessageFieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_MESSAGE);
    return ToJson(reflection->GetRepeatedMessage(message, field, index),
                  result);
  }

  absl::Status RepeatedEnumFieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_ENUM);
    ABSL_DCHECK_NE(field->enum_type()->full_name(),
                   "google.protobuf.NullValue");
    if (const auto* value = reflection->GetRepeatedEnum(message, field, index);
        value != nullptr) {
      SetStringValue(result, value->name());
    } else {
      SetNumberValue(result,
                     reflection->GetRepeatedEnumValue(message, field, index));
    }
    return absl::OkStatus();
  }

  absl::Status RepeatedNullFieldToValue(
      const google::protobuf::Reflection* absl_nonnull reflection,
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
      google::protobuf::MessageLite* absl_nonnull result) {
    ABSL_DCHECK_EQ(reflection, message.GetReflection());
    ABSL_DCHECK(!field->is_map() && field->is_repeated());
    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_ENUM);
    ABSL_DCHECK_EQ(field->enum_type()->full_name(),
                   "google.protobuf.NullValue");
    SetNullValue(result);
    return absl::OkStatus();
  }

  absl::Status MessageMapFieldToJson(
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    const auto* reflection = message.GetReflection();
    if (reflection->FieldSize(message, field) == 0) {
      return absl::OkStatus();
    }
    const auto key_to_string =
        GetMapFieldKeyToString(field->message_type()->map_key());
    const auto* value_descriptor = field->message_type()->map_value();
    CEL_ASSIGN_OR_RETURN(const auto value_to_value,
                         GetMapFieldValueToValue(value_descriptor));
    auto begin = extensions::protobuf_internal::ConstMapBegin(*reflection,
                                                              message, *field);
    const auto end = extensions::protobuf_internal::ConstMapEnd(
        *reflection, message, *field);
    for (; begin != end; ++begin) {
      auto key = (*key_to_string)(begin.GetKey());
      CEL_RETURN_IF_ERROR((this->*value_to_value)(
          begin.GetValueRef(), value_descriptor, InsertField(result, key)));
    }
    return absl::OkStatus();
  }

  absl::Status MessageRepeatedFieldToJson(
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    const auto* reflection = message.GetReflection();
    const int size = reflection->FieldSize(message, field);
    if (size == 0) {
      return absl::OkStatus();
    }
    CEL_ASSIGN_OR_RETURN(const auto to_value, GetRepeatedFieldToValue(field));
    for (int index = 0; index < size; ++index) {
      CEL_RETURN_IF_ERROR((this->*to_value)(reflection, message, field, index,
                                            AddValues(result)));
    }
    return absl::OkStatus();
  }

  absl::Status MessageFieldToJson(
      const google::protobuf::Message& message,
      const google::protobuf::FieldDescriptor* absl_nonnull field,
      google::protobuf::MessageLite* absl_nonnull result) {
    if (field->is_map()) {
      return MessageMapFieldToJson(message, field, MutableStructValue(result));
    }
    if (field->is_repeated()) {
      return MessageRepeatedFieldToJson(message, field,
                                        MutableListValue(result));
    }
    const auto* reflection = message.GetReflection();
    switch (field->type()) {
      case FieldDescriptor::TYPE_DOUBLE:
        SetNumberValue(result, reflection->GetDouble(message, field));
        break;
      case FieldDescriptor::TYPE_FLOAT:
        SetNumberValue(result, reflection->GetFloat(message, field));
        break;
      case FieldDescriptor::TYPE_FIXED64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_UINT64:
        SetNumberValue(result, reflection->GetUInt64(message, field));
        break;
      case FieldDescriptor::TYPE_BOOL:
        SetBoolValue(result, reflection->GetBool(message, field));
        break;
      case FieldDescriptor::TYPE_STRING:
        StringValueToJson(
            well_known_types::GetStringField(message, field, scratch_), result);
        break;
      case FieldDescriptor::TYPE_GROUP:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_MESSAGE:
        return ToJson((reflection->GetMessage)(message, field), result);
      case FieldDescriptor::TYPE_BYTES:
        BytesValueToJson(
            well_known_types::GetBytesField(message, field, scratch_), result);
        break;
      case FieldDescriptor::TYPE_FIXED32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_UINT32:
        SetNumberValue(result, reflection->GetUInt32(message, field));
        break;
      case FieldDescriptor::TYPE_ENUM: {
        const auto* enum_descriptor = field->enum_type();
        if (enum_descriptor->full_name() == "google.protobuf.NullValue") {
          SetNullValue(result);
        } else {
          const auto* enum_value_descriptor =
              reflection->GetEnum(message, field);
          if (enum_value_descriptor != nullptr) {
            SetStringValue(result, enum_value_descriptor->name());
          } else {
            SetNumberValue(result, reflection->GetEnumValue(message, field));
          }
        }
      } break;
      case FieldDescriptor::TYPE_SFIXED32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_SINT32:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_INT32:
        SetNumberValue(result, reflection->GetInt32(message, field));
        break;
      case FieldDescriptor::TYPE_SFIXED64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_SINT64:
        ABSL_FALLTHROUGH_INTENDED;
      case FieldDescriptor::TYPE_INT64:
        SetNumberValue(result, reflection->GetInt64(message, field));
        break;
      default:
        return absl::InvalidArgumentError(absl::StrCat(
            "unexpected message field type: ", field->type_name()));
    }
    return absl::OkStatus();
  }

  absl::Status MessageToJson(const google::protobuf::Message& message,
                             google::protobuf::MessageLite* absl_nonnull result) {
    std::vector<const google::protobuf::FieldDescriptor*> fields;
    const auto* reflection = message.GetReflection();
    reflection->ListFields(message, &fields);
    if (!fields.empty()) {
      for (const auto* field : fields) {
        CEL_RETURN_IF_ERROR(MessageFieldToJson(
            message, field, InsertField(result, field->json_name())));
      }
    }
    return absl::OkStatus();
  }

  void StringValueToJson(const well_known_types::StringValue& value,
                         google::protobuf::MessageLite* absl_nonnull result) const {
    absl::visit(absl::Overload([&](absl::string_view string)
                                   -> void { SetStringValue(result, string); },
                               [&](const absl::Cord& cord) -> void {
                                 SetStringValue(result, cord);
                               }),
                AsVariant(value));
  }

  void BytesValueToJson(const well_known_types::BytesValue& value,
                        google::protobuf::MessageLite* absl_nonnull result) const {
    absl::visit(absl::Overload(
                    [&](absl::string_view string) -> void {
                      SetStringValueFromBytes(result, string);
                    },
                    [&](const absl::Cord& cord) -> void {
                      SetStringValueFromBytes(result, cord);
                    }),
                AsVariant(value));
  }

  virtual void SetNullValue(
      google::protobuf::MessageLite* absl_nonnull message) const = 0;

  virtual void SetBoolValue(google::protobuf::MessageLite* absl_nonnull message,
                            bool value) const = 0;

  virtual void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
                              double value) const = 0;

  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
                      float value) const {
    SetNumberValue(message, static_cast<double>(value));
  }

  virtual void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
                              int64_t value) const = 0;

  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
                      int32_t value) const {
    SetNumberValue(message, static_cast<double>(value));
  }

  virtual void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
                              uint64_t value) const = 0;

  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
                      uint32_t value) const {
    SetNumberValue(message, static_cast<double>(value));
  }

  virtual void SetStringValue(google::protobuf::MessageLite* absl_nonnull message,
                              absl::string_view value) const = 0;

  virtual void SetStringValue(google::protobuf::MessageLite* absl_nonnull message,
                              const absl::Cord& value) const = 0;

  void SetStringValueFromBytes(google::protobuf::MessageLite* absl_nonnull message,
                               absl::string_view value) const {
    if (value.empty()) {
      SetStringValue(message, value);
      return;
    }
    SetStringValue(message, absl::Base64Escape(value));
  }

  void SetStringValueFromBytes(google::protobuf::MessageLite* absl_nonnull message,
                               const absl::Cord& value) const {
    if (value.empty()) {
      SetStringValue(message, value);
      return;
    }