// Copyright 2020 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 "tools/fidlcat/lib/statistics.h"

#include <algorithm>
#include <vector>

#include "tools/fidlcat/lib/syscall_decoder_dispatcher.h"
#include "tools/fidlcat/proto/session.pb.h"

namespace fidlcat {

void CloseHandleVisitor::VisitHandleValue(const fidl_codec::HandleValue* node,
                                          const fidl_codec::Type* for_type) {
  HandleInfo* handle_info =
      output_event_->thread()->process()->SearchHandleInfo(node->handle().handle);
  if (handle_info != nullptr) {
    handle_info->AddCloseEvent(output_event_);
  }
}

void CreateHandleVisitor::VisitHandleValue(const fidl_codec::HandleValue* node,
                                           const fidl_codec::Type* for_type) {
  HandleInfo* handle_info =
      output_event_->thread()->process()->SearchHandleInfo(node->handle().handle);
  if (handle_info != nullptr) {
    handle_info->AddCreationEvent(output_event_);
  }
}

void SyscallDisplayDispatcher::DisplaySummary(std::ostream& os) {
  const char* separator = "";
  // Displays all the processes one after the other.
  for (const auto& process : processes()) {
    FidlcatPrinter printer(
        this, process.second.get(), os,
        extra_generation_needs_colors() ? fidl_codec::WithColors : fidl_codec::WithoutColors, "");
    printer << separator;
    for (int i = 0; i < columns(); ++i) {
      printer << '-';
    }
    printer << *process.second;
    if (!process.second->handle_infos().empty()) {
      printer << ": " << process.second->handle_infos().size()
              << ((process.second->handle_infos().size() == 1) ? " handle" : " handles");
    }
    printer << '\n';
    fidl_codec::Indent indent(printer);
    // For one process, displays all the handles of the process one after the other.
    for (const auto& handle_info : process.second->handle_infos()) {
      printer << '\n';
      if (handle_info->startup()) {
        printer << fidl_codec::Red << "startup " << fidl_codec::ResetColor;
      }
      if (handle_info->object_type() == ZX_OBJ_TYPE_NONE) {
        printer << fidl_codec::Red << "handle " << fidl_codec::ResetColor;
      }
      printer.DisplayHandleInfo(handle_info);
      printer << '\n';
      {
        fidl_codec::Indent indent(printer);
        bool link_displayed = false;
        zx_handle_t linked_handle =
            inference().GetLinkedHandle(process.second->koid(), handle_info->handle());
        if (linked_handle != ZX_HANDLE_INVALID) {
          // Sometimes, a process creates a pair of channel ends (zx_channel_create).
          // Here, we display the relation between thoise two channel ends.
          printer << "linked to ";
          printer.DisplayHandle(linked_handle);
          printer << '\n';
          link_displayed = true;
        }
        zx_koid_t linked_koid = inference().GetLinkedKoid(handle_info->koid());
        if (linked_koid != ZX_KOID_INVALID) {
          // Sometimes, for channels, we know which process owns the other end. Because the other
          // end may have travelled from one process to another, we may have several processes.
          const std::set<HandleInfo*>* linked_koid_handle_infos =
              inference().GetKoidHandleInfos(linked_koid);
          if (linked_koid_handle_infos != nullptr) {
            for (const auto linked_handle_info : *linked_koid_handle_infos) {
              Process* linked_process = linked_handle_info->thread()->process();
              if (linked_process != process.second.get()) {
                // We only display a relation if it's not in the same process (we already displayed
                // the relation inside the process).
                if (link_displayed) {
                  printer << "which is  ";
                } else {
                  // We haven't displayed yet a relation for the handle (it's not a channel created
                  // by zx_channel_create by the process).
                  printer << "linked to ";
                  link_displayed = true;
                }
                printer.DisplayHandleInfo(linked_handle_info);
                printer << " in process " << linked_process->name() << ':' << fidl_codec::Red
                        << linked_process->koid() << fidl_codec::ResetColor << '\n';
              }
            }
          }
        }
        // Displays all the sessions for the handle.
        const char* separator = "";
        for (const auto& session : handle_info->sessions()) {
          printer << separator;
          const OutputEvent* creation_event = session->creation_event();
          if (creation_event != nullptr) {
            if (printer.display_stack_frame()) {
              printer.DisplayStackFrame(creation_event->invoked_event()->stack_frame());
            }
            // Displays the creation event for the session.
            printer << "created by ";
            if (creation_event->syscall()->kind() == SyscallKind::kRegularSyscall) {
              // The creation event is something like zx_channel_create, zx_timer_create, ...
              printer << fidl_codec::Green << creation_event->syscall()->name()
                      << fidl_codec::ResetColor;
            } else {
              // The creation event is a message read from a channel (for example zx_channel_read).
              // The process received the event from the message.
              auto creation_handle_info = creation_event->invoked_event()->GetHandleInfo(
                  creation_event->syscall()->SearchInlineMember("handle", /*invoked=*/true));
              FX_DCHECK(creation_handle_info != nullptr);
              printer.DisplayHandleInfo(creation_handle_info);
              const fidl_codec::FidlMessageValue* message = creation_event->GetMessage();
              FX_DCHECK(message != nullptr);
              FX_DCHECK(message->method() != nullptr);
              printer << " receiving " << fidl_codec::Green
                      << message->method()->fully_qualified_name() << fidl_codec::ResetColor;
            }
            printer << '\n';
          }
          // Displays all the regular events for the handle.
          {
            fidl_codec::Indent indent(printer);
            for (const auto& event : session->events()) {
              event->Display(printer);
            }
          }
          const OutputEvent* close_event = session->close_event();
          if (close_event != nullptr) {
            // Displays the close event for the session.
            printer << "closed by ";
            if (close_event->syscall()->kind() == SyscallKind::kRegularSyscall) {
              // The close event is zx_handle_close or zx_handle_close_many.
              printer << fidl_codec::Green << close_event->syscall()->name()
                      << fidl_codec::ResetColor;
            } else {
              // The close event is a message sent to a channel to another process (for example
              // zx_channel_write).
              // The process sent the event using the message.
              auto close_handle_info = close_event->invoked_event()->GetHandleInfo(
                  close_event->syscall()->SearchInlineMember("handle", /*invoked=*/true));
              FX_DCHECK(close_handle_info != nullptr);
              printer.DisplayHandleInfo(close_handle_info);
              const fidl_codec::FidlMessageValue* message =
                  close_event->invoked_event()->GetMessage();
              FX_DCHECK(message != nullptr);
              FX_DCHECK(message->method() != nullptr);
              printer << " sending " << fidl_codec::Green
                      << message->method()->fully_qualified_name() << fidl_codec::ResetColor;
            }
            printer << '\n';
          }
          separator = "\n";
        }
      }
    }
    separator = "\n";
  }
}

void SyscallDisplayDispatcher::DisplayThreads(std::ostream& os) {
  std::vector<zx_koid_t> process_koids;
  for (const auto& process : processes()) {
    process_koids.emplace_back(process.first);
  }
  std::sort(process_koids.begin(), process_koids.end());
  for (auto process_koid : process_koids) {
    Process* process = processes()[process_koid].get();
    FidlcatPrinter printer(
        this, process, os,
        extra_generation_needs_colors() ? fidl_codec::WithColors : fidl_codec::WithoutColors, "");
    std::vector<zx_koid_t> thread_koids;
    for (const auto& thread : threads()) {
      if (thread.second->process()->koid() == process_koid) {
        thread_koids.emplace_back(thread.first);
      }
    }
    std::sort(thread_koids.begin(), thread_koids.end());
    for (auto thread_koid : thread_koids) {
      Thread* thread = threads()[thread_koid].get();
      printer << "\n";
      printer << "thread " << process->name() << " " << fidl_codec::Red << process_koid
              << fidl_codec::ResetColor << ":" << fidl_codec::Red << thread_koid
              << fidl_codec::ResetColor << "\n";
      printer << "---------------------------------------------\n";
      for (const auto& event : decoded_events()) {
        if (event->ForThread(thread)) {
          event->Display(printer);
        }
      }
    }
  }
}

}  // namespace fidlcat