// 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.

#ifndef GOOGLE_PROTOBUF_FIELD_ACCESS_LISTENER_H__
#define GOOGLE_PROTOBUF_FIELD_ACCESS_LISTENER_H__

#include <cstddef>
#include <functional>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/arenastring.h>
//#include <google/protobuf/descriptor.h> // ypj, 2021-09-15, comment out
#include <google/protobuf/map.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/repeated_field.h>

// ypj, 2021-09-15, add
namespace google {
	namespace protobuf {
		class FieldDescriptor;
		class Descriptor;
	}
}

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
struct ResolvedType {
  using type = T;
};
}  // namespace internal
// Tracks the events of field accesses for all protos
// that are built with --inject_field_listener_events. This is a global
// interface which you must implement yourself and register with
// RegisterListener() function. All events consist of Descriptors,
// FieldAccessTypes and the underlying storage for tracking the memory which is
// accessed where possible and makes sense. Users are responsible for the
// implementations to be thread safe.
class FieldAccessListener {
 public:
  FieldAccessListener() = default;
  virtual ~FieldAccessListener() = default;

  // The memory annotations of the proto fields that are touched by the
  // accessors. They are returned as if the operation completes.
  struct DataAnnotation {
    DataAnnotation() = default;
    DataAnnotation(const void* other_address, size_t other_size)
        : address(other_address), size(other_size) {}
    const void* address = nullptr;
    size_t size = 0;
  };
  using AddressInfo = std::vector<DataAnnotation>;
  using AddressInfoExtractor = std::function<AddressInfo()>;

  enum class FieldAccessType {
    kAdd,          // add_<field>(f)
    kAddMutable,   // add_<field>()
    kGet,          // <field>() and <repeated_field>(i)
    kClear,        // clear_<field>()
    kHas,          // has_<field>()
    kList,         // <repeated_field>()
    kMutable,      // mutable_<field>()
    kMutableList,  // mutable_<repeated_field>()
    kRelease,      // release_<field>()
    kSet,          // set_<field>() and set_<repeated_field>(i)
    kSize,         // <repeated_field>_size()
  };

  static FieldAccessListener* GetListener();

  // Registers the field listener, can be called only once, |listener| must
  // outlive all proto accesses (in most cases, the lifetime of the program).
  static void RegisterListener(FieldAccessListener* listener);

  // All field accessors noted in FieldAccessType have this call.
  // |extractor| extracts the address info from the field
  virtual void OnFieldAccess(const AddressInfoExtractor& extractor,
                             const FieldDescriptor* descriptor,
                             FieldAccessType access_type) = 0;

  // Side effect calls.
  virtual void OnDeserializationAccess(const Message* message) = 0;
  virtual void OnSerializationAccess(const Message* message) = 0;
  virtual void OnReflectionAccess(const Descriptor* descriptor) = 0;
  virtual void OnByteSizeAccess(const Message* message) = 0;
  // We can probably add more if we need to, like {Merge,Copy}{From}Access.

  // Extracts all the addresses from the underlying fields.
  template <typename T>
  AddressInfo ExtractFieldInfo(const T* field_value);


 private:
  template <typename T>
  AddressInfo ExtractFieldInfoSpecific(const T* field_value,
                                       internal::ResolvedType<T>);

  AddressInfo ExtractFieldInfoSpecific(const Message* field_value,
                                       internal::ResolvedType<Message>);

  AddressInfo ExtractFieldInfoSpecific(const std::string* field_value,
                                       internal::ResolvedType<std::string>);

  AddressInfo ExtractFieldInfoSpecific(
      const internal::ArenaStringPtr* field_value,
      internal::ResolvedType<internal::ArenaStringPtr>);

  template <typename T>
  AddressInfo ExtractFieldInfoSpecific(
      const RepeatedField<T>* field_value,
      internal::ResolvedType<RepeatedField<T>>);

  template <typename T>
  AddressInfo ExtractFieldInfoSpecific(
      const RepeatedPtrField<T>* field_value,
      internal::ResolvedType<RepeatedPtrField<T>>);

  template <typename K, typename V>
  AddressInfo ExtractFieldInfoSpecific(const Map<K, V>* field_value,
                                       internal::ResolvedType<Map<K, V>>);

  static internal::once_flag register_once_;
  static FieldAccessListener* field_listener_;
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldAccessListener);
};

template <typename T>
inline FieldAccessListener::AddressInfo FieldAccessListener::ExtractFieldInfo(
    const T* field_value) {
  return ExtractFieldInfoSpecific(field_value, internal::ResolvedType<T>());
}


template <typename T>
inline FieldAccessListener::AddressInfo
FieldAccessListener::ExtractFieldInfoSpecific(const T* field_value,
                                              internal::ResolvedType<T>) {
  static_assert(std::is_trivial<T>::value,
                "This overload should be chosen only for trivial types");
  return FieldAccessListener::AddressInfo{FieldAccessListener::DataAnnotation(
      static_cast<const void*>(field_value), sizeof(*field_value))};
}

inline FieldAccessListener::AddressInfo
FieldAccessListener::ExtractFieldInfoSpecific(
    const std::string* field_value, internal::ResolvedType<std::string>) {
  return FieldAccessListener::AddressInfo{FieldAccessListener::DataAnnotation(
      static_cast<const void*>(field_value->c_str()), field_value->length())};
}

inline FieldAccessListener::AddressInfo
FieldAccessListener::ExtractFieldInfoSpecific(
    const internal::ArenaStringPtr* field_value,
    internal::ResolvedType<internal::ArenaStringPtr>) {
  return FieldAccessListener::ExtractFieldInfoSpecific(
      field_value->GetPointer(), internal::ResolvedType<std::string>());
}

template <typename T>
inline FieldAccessListener::AddressInfo
FieldAccessListener::ExtractFieldInfoSpecific(
    const RepeatedField<T>* field_value,
    internal::ResolvedType<RepeatedField<T>>) {
  // TODO(jianzhouzh): This can cause data races. Synchronize this if needed.
  FieldAccessListener::AddressInfo address_info;
  address_info.reserve(field_value->size());
  for (int i = 0, ie = field_value->size(); i < ie; ++i) {
    auto sub = ExtractFieldInfoSpecific(&field_value->Get(i),
                                        internal::ResolvedType<T>());
    address_info.insert(address_info.end(), sub.begin(), sub.end());
  }
  return address_info;
}

template <typename T>
inline FieldAccessListener::AddressInfo
FieldAccessListener::ExtractFieldInfoSpecific(
    const RepeatedPtrField<T>* field_value,
    internal::ResolvedType<RepeatedPtrField<T>>) {
  FieldAccessListener::AddressInfo address_info;
  // TODO(jianzhouzh): This can cause data races. Synchronize this if needed.
  address_info.reserve(field_value->size());
  for (int i = 0, ie = field_value->size(); i < ie; ++i) {
    auto sub = ExtractFieldInfoSpecific(&field_value->Get(i),
                                        internal::ResolvedType<T>());
    address_info.insert(address_info.end(), sub.begin(), sub.end());
  }
  return address_info;
}

template <typename K, typename V>
inline FieldAccessListener::AddressInfo
FieldAccessListener::ExtractFieldInfoSpecific(
    const Map<K, V>* field_value, internal::ResolvedType<Map<K, V>>) {
  // TODO(jianzhouzh): This can cause data races. Synchronize this if needed.
  FieldAccessListener::AddressInfo address_info;
  address_info.reserve(field_value->size());
  for (auto it = field_value->begin(); it != field_value->end(); ++it) {
    auto sub_first =
        ExtractFieldInfoSpecific(&it->first, internal::ResolvedType<K>());
    auto sub_second =
        ExtractFieldInfoSpecific(&it->second, internal::ResolvedType<V>());
    address_info.insert(address_info.end(), sub_first.begin(), sub_first.end());
    address_info.insert(address_info.end(), sub_second.begin(),
                        sub_second.end());
  }
  return address_info;
}

inline FieldAccessListener::AddressInfo
FieldAccessListener::ExtractFieldInfoSpecific(const Message* field_value,
                                              internal::ResolvedType<Message>) {
  // TODO(jianzhouzh): implement and adjust all annotations in the compiler.
  return {};
}

}  // namespace protobuf
}  // namespace google

#endif  // GOOGLE_PROTOBUF_FIELD_ACCESS_LISTENER_H__
