#ifndef SRC_TRACING_NODE_TRACE_WRITER_H_

#define SRC_TRACING_NODE_TRACE_WRITER_H_

#include <sstream>

#include <queue>

#include "libplatform/v8-tracing.h"

#include "tracing/agent.h"

#include "uv.h"

namespace node {

namespace tracing {

using v8::platform::tracing::TraceObject;

using v8::platform::tracing::TraceWriter;

class NodeTraceWriter : public AsyncTraceWriter {

 public:

  explicit NodeTraceWriter(const std::string& log_file_pattern);

  ~NodeTraceWriter() override;

  void InitializeOnThread(uv_loop_t* loop) override;

  void AppendTraceEvent(TraceObject* trace_event) override;

  void Flush(bool blocking) override;

  static const int kTracesPerFile = 1 << 19;

 private:

    std::string str;

    int highest_request_id;

  };

  void AfterWrite();

  void StartWrite(uv_buf_t buf);

  void OpenNewFileForStreaming();

  void WriteToFile(std::string&& str, int highest_request_id);

  void WriteSuffix();

  void FlushPrivate();

  static void ExitSignalCb(uv_async_t* signal);

  uv_loop_t* tracing_loop_ = nullptr;

  // Triggers callback to initiate writing the contents of stream_ to disk.

  uv_async_t flush_signal_;

  // Triggers callback to close async objects, ending the tracing thread.

  uv_async_t exit_signal_;

  // Prevents concurrent R/W on state related to serialized trace data

  // before it's written to disk, namely stream_ and total_traces_

  // as well as json_trace_writer_.

  Mutex stream_mutex_;

  // Prevents concurrent R/W on state related to write requests.

  // If both mutexes are locked, request_mutex_ has to be locked first.

  Mutex request_mutex_;

  // Allows blocking calls to Flush() to wait on a condition for

  // trace events to be written to disk.

  ConditionVariable request_cond_;

  // Used to wait until async handles have been closed.

  ConditionVariable exit_cond_;

  int fd_ = -1;

  uv_fs_t write_req_;

  std::queue<WriteRequest> write_req_queue_;

  int num_write_requests_ = 0;

  int highest_request_id_completed_ = 0;

  int total_traces_ = 0;

  int file_num_ = 0;

  std::string log_file_pattern_;

  std::ostringstream stream_;

  std::unique_ptr<TraceWriter> json_trace_writer_;

  bool exited_ = false;

};

}  // namespace tracing

}  // namespace node

#endif  // SRC_TRACING_NODE_TRACE_WRITER_H_