// Copyright 2016 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#ifndef SRC_TRACING_TRACED_VALUE_H_

#define SRC_TRACING_TRACED_VALUE_H_

#include "v8-platform.h"

#include <cstdint>

#include <span>

#include <string>

namespace node {

namespace tracing {

template <typename T>

std::unique_ptr<v8::ConvertableToTraceFormat> CastTracedValue(const T& value) {

  return value.Cast();

}

Unexecuted instantiation: std::__1::unique_ptr<v8::ConvertableToTraceFormat, std::__1::default_delete<v8::ConvertableToTraceFormat> > node::tracing::CastTracedValue<node::tracing::ProcessMeta>(node::tracing::ProcessMeta const&)

Unexecuted instantiation: std::__1::unique_ptr<v8::ConvertableToTraceFormat, std::__1::default_delete<v8::ConvertableToTraceFormat> > node::tracing::CastTracedValue<node::tracing::AsyncWrapArgs>(node::tracing::AsyncWrapArgs const&)

Unexecuted instantiation: std::__1::unique_ptr<v8::ConvertableToTraceFormat, std::__1::default_delete<v8::ConvertableToTraceFormat> > node::tracing::CastTracedValue<node::tracing::EnvironmentArgs>(node::tracing::EnvironmentArgs const&)

class EnvironmentArgs {

 public:

  EnvironmentArgs(std::span<const std::string> args,

                  std::span<const std::string> exec_args)

      : args_(args), exec_args_(exec_args) {}

  std::unique_ptr<v8::ConvertableToTraceFormat> Cast() const;

 private:

  std::span<const std::string> args_;

  std::span<const std::string> exec_args_;

};

class AsyncWrapArgs {

 public:

  AsyncWrapArgs(int64_t execution_async_id, int64_t trigger_async_id)

      : execution_async_id_(execution_async_id),

        trigger_async_id_(trigger_async_id) {}

  std::unique_ptr<v8::ConvertableToTraceFormat> Cast() const;

 private:

  int64_t execution_async_id_;

  int64_t trigger_async_id_;

};

class ProcessMeta {

 public:

  std::unique_ptr<v8::ConvertableToTraceFormat> Cast() const;

};

// Do not use this class directly. Define a custom structured class to provide

// a conversion method so that the class can be used with both V8 legacy

// trace API and perfetto API.

//

// These classes provide a JSON-inspired way to write structed data into traces.

//

// To define how a custom class should be written into the trace, users should

// define one of the two following functions:

// - Foo::Cast(TracedValue) const

//   (preferred for code which depends on perfetto directly)

//

// After defining a conversion method, the object can be used as a

// TRACE_EVENT argument:

//

// Foo foo;

// TRACE_EVENT("cat", "Event", "arg", CastTracedValue(foo));

//

// class Foo {

//   std::unique_ptr<v8::ConvertableToTraceFormat> Cast() const {

//     auto traced_value = tracing::TracedValue::Create();

//     dict->SetInteger("key", 42);

//     dict->SetString("foo", "bar");

//     return traced_value;

//   }

// }

class TracedValue : public v8::ConvertableToTraceFormat {

 public:

  ~TracedValue() override = default;

  static std::unique_ptr<TracedValue> Create();

  static std::unique_ptr<TracedValue> CreateArray();

  void EndDictionary();

  void EndArray();

  // These methods assume that |name| is a long lived "quoted" string.

  void SetInteger(const char* name, int value);

  void SetDouble(const char* name, double value);

  void SetBoolean(const char* name, bool value);

  void SetNull(const char* name);

  void SetString(const char* name, const char* value);

  void SetString(const char* name, const std::string& value) {

    SetString(name, value.c_str());

  }

  void BeginDictionary(const char* name);

  void BeginArray(const char* name);

  void AppendInteger(int);

  void AppendDouble(double);

  void AppendBoolean(bool);

  void AppendNull();

  void AppendString(const char*);

  void AppendString(const std::string& value) { AppendString(value.c_str()); }

  void BeginArray();

  void BeginDictionary();

  // ConvertableToTraceFormat implementation.

  void AppendAsTraceFormat(std::string* out) const override;

  TracedValue(const TracedValue&) = delete;

  TracedValue& operator=(const TracedValue&) = delete;

 private:

  explicit TracedValue(bool root_is_array = false);

  void WriteComma();

  void WriteName(const char* name);

  std::string data_;

  bool first_item_;

  bool root_is_array_;

};

}  // namespace tracing

}  // namespace node

#endif  // SRC_TRACING_TRACED_VALUE_H_