// Copyright 2023 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/trace-provider/provider.h>
#include <lib/trace/event.h>
#include <unistd.h>

#include <thread>

#include "lib/async/cpp/task.h"
#include "zircon/system/public/zircon/process.h"

size_t async_id = 0;
size_t flow_id = 0;
uint64_t data = 0;
uint64_t data2 = UINT32_MAX;
void EmitSomeEvents(async_dispatcher_t* dispatcher) {
  // The simplest trace event is an instant event, which marks a point in time. It has both a name
  // and a category to differentiate it. It will show up in the Perfetto UI as a little arrow.
  TRACE_INSTANT("example", "example_instant", TRACE_SCOPE_THREAD);

  TRACE_COUNTER("example", "example_counter", 0, "somedataseries", data++);
  TRACE_COUNTER("example", "example_counter2", 1, "someotherdataseries", data2--);

  // Only slightly more complicated is a duration event, which marks _two_ points in time.
  // It will appear in the viewer as a block
  TRACE_DURATION_BEGIN("example", "example_duration");
  usleep(50000);
  // It needs to be matched by a duration end with the same name and category.
  TRACE_DURATION_END("example", "example_duration");
  // Alternatively, you can use the RAII macro which will automatically handle this for you when it
  // goes out of scope.
  TRACE_DURATION("example", "example_duration_raii");
  usleep(25000);

  // You can use async events to record an operation that may occur across threads.
  // In the viewer, the events will appear linearly on their own track based on the name of the
  // async begin event as opposed to the thread they were emitted on.
  TRACE_ASYNC_BEGIN("example", "example_async", async_id);
  TRACE_ASYNC_BEGIN("example", "example_async2", async_id + 1);
  std::thread thread1([id = async_id] {
    usleep(5000);
    TRACE_ASYNC_INSTANT("example", "example_async_instant1", id);
  });
  std::thread thread2([id = async_id] {
    usleep(10000);
    TRACE_ASYNC_INSTANT("example", "example_async_instant2", id);
  });
  std::thread thread3([id = async_id] {
    usleep(5000);
    TRACE_ASYNC_INSTANT("example", "example_async_instant3", id + 1);
  });
  std::thread thread4([id = async_id] {
    usleep(10000);
    TRACE_ASYNC_INSTANT("example", "example_async_instant4", id + 1);
  });
  thread1.join();
  thread2.join();
  thread3.join();
  thread4.join();
  TRACE_ASYNC_END("example", "example_async", async_id);
  TRACE_ASYNC_END("example", "example_async2", async_id + 1);
  async_id += 2;

  // Flow events allow you to link together duration events that may occur across threads or
  // abstraction layers. Each flow event must be enclosed by a duration event. The viewer then
  // displays the flow events as arrows connecting each of the duration events.
  TRACE_FLOW_BEGIN("example", "example_flow", flow_id);
  TRACE_FLOW_BEGIN("example", "example_flow2", flow_id + 1);
  std::thread thread5([id = flow_id] {
    TRACE_DURATION("example", "thread5");
    usleep(1000);
    TRACE_FLOW_STEP("example", "example_flow_step1", id);
  });
  std::thread thread6([id = flow_id] {
    TRACE_DURATION("example", "thread6");
    usleep(2000);
    TRACE_FLOW_STEP("example", "example_flow_step2", id);
  });
  std::thread thread7([id = flow_id] {
    TRACE_DURATION("example", "thread7");
    usleep(3000);
    TRACE_FLOW_STEP("example", "example_flow_step3", id + 1);
  });
  std::thread thread8([id = flow_id] {
    TRACE_DURATION("example", "thread8");
    usleep(4000);
    TRACE_FLOW_STEP("example", "example_flow_step4", id + 1);
  });
  std::thread thread9([id = flow_id] {
    TRACE_DURATION("example", "thread9");
    usleep(5000);
    TRACE_FLOW_END("example", "example_flow", id);
  });
  std::thread thread10([id = flow_id] {
    TRACE_DURATION("example", "thread10");
    usleep(6000);
    TRACE_FLOW_END("example", "example_flow2", id + 1);
  });
  thread5.join();
  thread6.join();
  thread7.join();
  thread8.join();
  thread9.join();
  thread10.join();
  flow_id += 2;

  // Trace Events can also have arguments associated with them that will show up when you click on
  // the event in the viewer
  //
  // Null arguments are just a name and no data
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "SomeNullArg", TA_NULL());
  // There are standard int types
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "Someuint32",
                uint32_t{2145});
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "Someuint64",
                uint64_t{423621626134123415});
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "Someint32", int32_t{-7});
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "Someint64",
                int64_t{-234516543631231});
  // Doubles
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "Somedouble",
                double{3.1415});

  // Strings
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "ping", "pong");

  // Pointers will format in hex in the viewer
  int i = 0;
  // You can also specifically specify the trace argument type when type deduction would otherwise
  // resolve to the wrong type.
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "somepointer", &i,
                "someotherpointer", TA_POINTER(0xABCD));

  // Koids has their own type, but it's really just a uint64_t that has special meaning on the most
  // significant bit being 1 or not.
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "somekoid", TA_KOID(0x0012));

  // Booleans with display as "true" or "false"
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "somebool", true);
  TRACE_INSTANT("example", "example_instant_args", TRACE_SCOPE_THREAD, "someotherbool", false);
  async::PostDelayedTask(
      dispatcher, [dispatcher] { EmitSomeEvents(dispatcher); }, zx::msec(10));
}

int main() {
  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);
  async_dispatcher_t* dispatcher = loop.dispatcher();
  // Once we link against tracing and include the tracing client shard, all we need to do in create
  // TraceProvider object.
  trace::TraceProviderWithFdio trace_provider(dispatcher, "example_trace_provider");

  // Let's continuously emit some trace events
  async::PostTask(dispatcher, [dispatcher] { EmitSomeEvents(dispatcher); });

  // Don't forget to start the loop!
  loop.Run();
  return 0;
}