// 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/event.h"

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

namespace fidlcat {

void Process::LoadHandleInfo(Inference* inference) {
  zxdb::Process* zxdb_process = zxdb_process_.get();
  if (zxdb_process == nullptr) {
    return;
  }
  if (loading_handle_info_) {
    // We are currently loading information about the handles. If we are unlucky, the result won't
    // include information about handles we are now needing. Ask the process to do another load just
    // after the current one to be sure to have all the handles we need (including the handle only
    // needed after the start of the load).
    needs_to_load_handle_info_ = true;
    return;
  }
  loading_handle_info_ = true;
  needs_to_load_handle_info_ = false;
  zxdb_process->LoadInfoHandleTable(
      [this, inference](zxdb::ErrOr<std::vector<debug_ipc::InfoHandle>> handles) {
        loading_handle_info_ = false;
        if (!handles.ok()) {
          FX_LOGS(ERROR) << "msg: " << handles.err().msg();
        } else {
          for (const auto& handle : handles.value()) {
            HandleInfo* handle_info = SearchHandleInfo(handle.handle_value);
            if (handle_info != nullptr) {
              // Associate the koid and the object type to the handle only if the handle is
              // currently used by the monitored process. That is if the handle if referenced by an
              // event.
              // That means that we may need an extra load if the handle is already known by the
              // kernel but not yet needed by the monitored process. This way we avoid creating
              // a Handle object for handles we don't know the semantic.
              handle_info->set_object_type(handle.type);
              handle_info->set_rights(handle.rights);
              handle_info->set_koid(handle.koid);
              inference->AddKoidHandleInfo(handle.koid, handle_info);
            }
            if (handle.related_koid != ZX_HANDLE_INVALID) {
              // However, the association of koids is always useful.
              inference->AddLinkedKoids(handle.koid, handle.related_koid);
            }
          }
          if (needs_to_load_handle_info_) {
            needs_to_load_handle_info_ = false;
            LoadHandleInfo(inference);
          }
        }
      });
}

void Protocol::AddEvent(const OutputEvent* event, const fidl_codec::FidlMessageValue* message) {
  Method* method = GetMethod(message->ordinal(), message->method());
  method->AddEvent(event);
  ++event_count_;
}

void Process::AddEvent(const OutputEvent* event, const fidl_codec::FidlMessageValue* message) {
  Protocol* protocol = GetProtocol(
      (message->method() != nullptr) ? &message->method()->enclosing_protocol() : nullptr);
  protocol->AddEvent(event, message);
  ++event_count_;
}

void ProcessLaunchedEvent::Write(proto::Event* dst) const {
  dst->set_timestamp(timestamp());
  proto::ProcessLaunchedEvent* event = dst->mutable_process_launched();
  event->set_command(command());
  event->set_error_message(error_message());
}

void ProcessMonitoredEvent::Write(proto::Event* dst) const {
  dst->set_timestamp(timestamp());
  proto::ProcessMonitoredEvent* event = dst->mutable_process_monitored();
  event->set_process_koid(process()->koid());
  event->set_error_message(error_message());
}

void StopMonitoringEvent::Write(proto::Event* dst) const {
  dst->set_timestamp(timestamp());
  proto::StopMonitoringEvent* event = dst->mutable_stop_monitoring();
  event->set_process_koid(process()->koid());
}

bool SyscallEvent::NeedsToLoadHandleInfo(Inference* inference) {
  for (const auto& field : inline_fields_) {
    if (field.second->NeedsToLoadHandleInfo(timestamp(), thread()->koid(), inference)) {
      return true;
    }
  }
  for (const auto& field : outline_fields_) {
    if (field.second->NeedsToLoadHandleInfo(timestamp(), thread()->koid(), inference)) {
      return true;
    }
  }
  return false;
}

const fidl_codec::FidlMessageValue* SyscallEvent::GetMessage() const {
  if (outline_fields_.size() == 0) {
    return nullptr;
  }
  return outline_fields_.begin()->second->AsFidlMessageValue();
}

const fidl_codec::Value* SyscallEvent::GetValue(const fidl_codec::StructMember* member) const {
  if (member == nullptr) {
    return nullptr;
  }
  auto result = inline_fields_.find(member);
  if (result != inline_fields_.end()) {
    return result->second.get();
  }
  auto result2 = outline_fields_.find(member);
  if (result2 != outline_fields_.end()) {
    return result2->second.get();
  }
  return nullptr;
}

const fidl_codec::HandleValue* SyscallEvent::GetHandleValue(
    const fidl_codec::StructMember* member) const {
  if (member == nullptr) {
    return nullptr;
  }
  auto result = inline_fields_.find(member);
  if (result == inline_fields_.end()) {
    return nullptr;
  }
  return result->second->AsHandleValue();
}

HandleInfo* SyscallEvent::GetHandleInfo(const fidl_codec::StructMember* member) const {
  if (member == nullptr) {
    return nullptr;
  }
  auto result = inline_fields_.find(member);
  if (result == inline_fields_.end()) {
    return nullptr;
  }
  const fidl_codec::HandleValue* value = result->second->AsHandleValue();
  if (value == nullptr) {
    return nullptr;
  }
  return thread()->process()->SearchHandleInfo(value->handle().handle);
}

void InvokedEvent::ComputeHandleInfo(SyscallDisplayDispatcher* dispatcher) {
  switch (syscall()->kind()) {
    case SyscallKind::kChannelRead:
    case SyscallKind::kChannelWrite:
    case SyscallKind::kChannelCall: {
      // Compute the handle which is used to read/write a message.
      FX_DCHECK(!syscall()->input_inline_members().empty());
      auto value = inline_fields().find(syscall()->input_inline_members()[0].get());
      FX_DCHECK(value != inline_fields().end());
      handle_info_ =
          thread()->process()->SearchHandleInfo(value->second->AsHandleValue()->handle().handle);
      if (handle_info_ == nullptr) {
        handle_info_ = dispatcher->CreateHandleInfo(
            thread(), value->second->AsHandleValue()->handle().handle, 0, false);
      }
      break;
    }
    default:
      break;
  }
}

void InvokedEvent::Write(proto::Event* dst) const {
  dst->set_timestamp(timestamp());
  proto::InvokedEvent* event = dst->mutable_invoked();
  event->set_thread_koid(thread()->koid());
  for (const auto& location : stack_frame_) {
    proto::Location* proto_location = event->add_frame();
    proto_location->set_path(location.path());
    proto_location->set_line(location.line());
    proto_location->set_column(location.column());
    proto_location->set_address(location.address());
    proto_location->set_symbol(location.symbol());
  }
  event->set_syscall(syscall()->name());
  for (const auto& field : inline_fields()) {
    fidl_codec::proto::Value value;
    fidl_codec::ProtoVisitor visitor(&value);
    field.second->Visit(&visitor, nullptr);
    if (field.first->id() != 0) {
      event->mutable_inline_id_fields()->insert(
          google::protobuf::MapPair(static_cast<uint32_t>(field.first->id()), value));
    } else {
      event->mutable_inline_fields()->insert(google::protobuf::MapPair(field.first->name(), value));
    }
  }
  for (const auto& field : outline_fields()) {
    fidl_codec::proto::Value value;
    fidl_codec::ProtoVisitor visitor(&value);
    field.second->Visit(&visitor, nullptr);
    if (field.first->id() != 0) {
      event->mutable_outline_id_fields()->insert(
          google::protobuf::MapPair(static_cast<uint32_t>(field.first->id()), value));
    } else {
      event->mutable_outline_fields()->insert(
          google::protobuf::MapPair(field.first->name(), value));
    }
  }
}

void InvokedEvent::PrettyPrint(FidlcatPrinter& printer) const {
  if (printer.display_stack_frame()) {
    printer.DisplayStackFrame(stack_frame_);
  }
  printer << syscall()->name();
  printer.DisplayInline(syscall()->input_inline_members(), inline_fields());
  printer << '\n';
  printer.DisplayOutline(syscall()->input_outline_members(), outline_fields());
}

void OutputEvent::Write(proto::Event* dst) const {
  dst->set_timestamp(timestamp());
  proto::OutputEvent* event = dst->mutable_output();
  event->set_thread_koid(thread()->koid());
  event->set_syscall(syscall()->name());
  event->set_returned_value(returned_value());
  event->set_invoked_event_id(invoked_event()->id());
  for (const auto& field : inline_fields()) {
    fidl_codec::proto::Value value;
    fidl_codec::ProtoVisitor visitor(&value);
    field.second->Visit(&visitor, nullptr);
    if (field.first->id() != 0) {
      event->mutable_inline_id_fields()->insert(
          google::protobuf::MapPair(static_cast<uint32_t>(field.first->id()), value));
    } else {
      event->mutable_inline_fields()->insert(google::protobuf::MapPair(field.first->name(), value));
    }
  }
  for (const auto& field : outline_fields()) {
    fidl_codec::proto::Value value;
    fidl_codec::ProtoVisitor visitor(&value);
    field.second->Visit(&visitor, nullptr);
    if (field.first->id() != 0) {
      event->mutable_outline_id_fields()->insert(
          google::protobuf::MapPair(static_cast<uint32_t>(field.first->id()), value));
    } else {
      event->mutable_outline_fields()->insert(
          google::protobuf::MapPair(field.first->name(), value));
    }
  }
}

void OutputEvent::Display(FidlcatPrinter& printer, bool with_channel) const {
  const fidl_codec::FidlMessageValue* message = invoked_event_->GetMessage();
  if (message == nullptr) {
    message = GetMessage();
    if (message == nullptr) {
      return;
    }
  }
  printer << fidl_codec::Green << printer.dispatcher()->GetTime(timestamp())
          << fidl_codec::ResetColor << ' ';
  switch (syscall()->kind()) {
    case SyscallKind::kChannelRead:
      printer << "read  ";
      break;
    case SyscallKind::kChannelWrite:
      printer << "write ";
      break;
    case SyscallKind::kChannelCall:
      printer << "call  ";
      break;
    default:
      return;
  }
  const fidl_codec::ProtocolMethod* method = message->method();
  if (message->ordinal() == kFidlOrdinalEpitaph) {
    printer << fidl_codec::WhiteOnMagenta << "epitaph " << fidl_codec::ResetColor << ' '
            << ((message->epitaph_error() == "ZX_OK") ? fidl_codec::Green : fidl_codec::Red)
            << message->epitaph_error() << fidl_codec::ResetColor;
  } else {
    if (method == nullptr) {
      printer << " ordinal=" << std::hex << message->ordinal() << std::dec;
    } else {
      printer << fidl_codec::WhiteOnMagenta
              << (message->is_request()
                      ? "request "
                      : ((method->request() != nullptr) ? "response" : "event   "))
              << fidl_codec::ResetColor << ' ' << fidl_codec::Green
              << method->enclosing_protocol().name() << '.' << method->name()
              << fidl_codec::ResetColor;
    }
  }
  bool first_argument = true;
  if (with_channel && (invoked_event()->handle_info() != nullptr)) {
    printer << '(';
    printer.DisplayHandleInfo(invoked_event()->handle_info());
    first_argument = false;
  }
  if ((method != nullptr) && (method->short_display() != nullptr)) {
    fidl_codec::Indent indent(printer);
    const fidl_codec::PayloadableValue* request =
        (syscall()->kind() == SyscallKind::kChannelRead)
            ? GetMessage()->decoded_request()
            : invoked_event()->GetMessage()->decoded_request();
    fidl_codec::semantic::SemanticContext context(&printer.inference(), printer.process()->koid(),
                                                  (invoked_event()->handle_info() == nullptr)
                                                      ? ZX_HANDLE_INVALID
                                                      : invoked_event()->handle_info()->handle(),
                                                  request, nullptr, invoked_event()->timestamp());
    for (const auto& expression : method->short_display()->inputs()) {
      if (first_argument) {
        printer << '(';
        first_argument = false;
      } else {
        printer << ", ";
      }
      expression->PrettyPrint(printer, &context);
    }
  }
  if (!first_argument) {
    printer << ')';
  }
  printer << '\n';
  if ((method != nullptr) && (method->short_display() != nullptr)) {
    fidl_codec::Indent indent(printer);
    const fidl_codec::PayloadableValue* request =
        (syscall()->kind() == SyscallKind::kChannelRead)
            ? GetMessage()->decoded_request()
            : invoked_event()->GetMessage()->decoded_request();
    fidl_codec::semantic::SemanticContext context(&printer.inference(), printer.process()->koid(),
                                                  (invoked_event()->handle_info() == nullptr)
                                                      ? ZX_HANDLE_INVALID
                                                      : invoked_event()->handle_info()->handle(),
                                                  request, nullptr, invoked_event()->timestamp());
    bool first_result = true;
    for (const auto& expression : method->short_display()->results()) {
      printer << (first_result ? "-> " : ", ");
      first_result = false;
      expression->PrettyPrint(printer, &context);
    }
    if (!first_result) {
      printer << '\n';
    }
  }
}

void OutputEvent::PrettyPrint(FidlcatPrinter& printer) const {
  fidl_codec::Indent indent(printer);

  switch (syscall()->return_type()) {
    case SyscallReturnType::kNoReturn:
      return;
    case SyscallReturnType::kVoid:
      if (inline_fields().empty() && outline_fields().empty()) {
        return;
      }
      printer << "-> ";
      break;
    case SyscallReturnType::kStatus:
      printer << "-> ";
      printer.DisplayStatus(static_cast<zx_status_t>(returned_value_));
      break;
    case SyscallReturnType::kTicks:
      printer << "-> " << fidl_codec::Green << "ticks" << fidl_codec::ResetColor << ": "
              << fidl_codec::Blue << static_cast<uint64_t>(returned_value_)
              << fidl_codec::ResetColor;
      break;
    case SyscallReturnType::kTime:
      printer << "-> " << fidl_codec::Green << "time" << fidl_codec::ResetColor << ": ";
      printer.DisplayTime(static_cast<zx_time_t>(returned_value_));
      break;
    case SyscallReturnType::kUint32:
      printer << "-> " << fidl_codec::Blue << static_cast<uint32_t>(returned_value_)
              << fidl_codec::ResetColor;
      break;
    case SyscallReturnType::kUint64:
      printer << "-> " << fidl_codec::Blue << static_cast<uint64_t>(returned_value_)
              << fidl_codec::ResetColor;
      break;
  }
  // Adds the inline output arguments (if any).
  if (!inline_fields().empty()) {
    printer << ' ';
    printer.DisplayInline(syscall()->output_inline_members(), inline_fields());
  }
  printer << '\n';
  printer.DisplayOutline(syscall()->output_outline_members(), outline_fields());
}

void ExceptionEvent::Write(proto::Event* dst) const {
  dst->set_timestamp(timestamp());
  proto::ExceptionEvent* event = dst->mutable_exception();
  event->set_thread_koid(thread()->koid());
  for (const auto& location : stack_frame_) {
    proto::Location* proto_location = event->add_frame();
    proto_location->set_path(location.path());
    proto_location->set_line(location.line());
    proto_location->set_column(location.column());
    proto_location->set_address(location.address());
    proto_location->set_symbol(location.symbol());
  }
}

void ExceptionEvent::PrettyPrint(FidlcatPrinter& printer) const {
  printer.DisplayStackFrame(stack_frame_);
  printer << fidl_codec::Red << "thread stopped on exception" << fidl_codec::ResetColor << '\n';
}

bool EventDecoder::DecodeAndDispatchEvent(const proto::Event& proto_event) {
  switch (proto_event.Kind_case()) {
    case proto::Event::kProcessLaunched: {
      const proto::ProcessLaunchedEvent& content = proto_event.process_launched();
      dispatcher_->AddProcessLaunchedEvent(std::make_shared<ProcessLaunchedEvent>(
          proto_event.timestamp(), content.command(), content.error_message()));
      return true;
    }
    case proto::Event::kProcessMonitored: {
      const proto::ProcessMonitoredEvent& content = proto_event.process_monitored();
      Process* process = dispatcher_->SearchProcess(content.process_koid());
      if (process == nullptr) {
        FX_LOGS(ERROR) << "Process " << content.process_koid() << " not found for event .";
        return false;
      }
      dispatcher_->AddProcessMonitoredEvent(std::make_shared<ProcessMonitoredEvent>(
          proto_event.timestamp(), process, content.error_message()));
      return true;
    }
    case proto::Event::kStopMonitoring: {
      const proto::StopMonitoringEvent& content = proto_event.stop_monitoring();
      Process* process = dispatcher_->SearchProcess(content.process_koid());
      if (process == nullptr) {
        FX_LOGS(ERROR) << "Process " << content.process_koid() << " not found for event .";
        return false;
      }
      dispatcher_->AddStopMonitoringEvent(
          std::make_shared<StopMonitoringEvent>(proto_event.timestamp(), process));
      return true;
    }
    case proto::Event::kInvoked: {
      const proto::InvokedEvent& content = proto_event.invoked();
      Thread* thread = dispatcher_->SearchThread(content.thread_koid());
      if (thread == nullptr) {
        FX_LOGS(ERROR) << "Thread " << content.thread_koid() << " not found for event.";
        return false;
      }
      Syscall* syscall = dispatcher_->SearchSyscall(content.syscall());
      if (syscall == nullptr) {
        FX_LOGS(ERROR) << "Syscall " << content.syscall() << " not found.";
        return false;
      }
      auto event = std::make_shared<InvokedEvent>(proto_event.timestamp(), thread, syscall);
      if (!DecodeValues(event.get(), content.inline_fields(), content.inline_id_fields(),
                        content.outline_fields(), content.outline_id_fields(),
                        /*invoked=*/true)) {
        return false;
      }
      for (int index = 0; index < content.frame_size(); ++index) {
        const proto::Location& proto_location = content.frame(index);
        event->stack_frame().emplace_back(proto_location.path(), proto_location.line(),
                                          proto_location.column(), proto_location.address(),
                                          proto_location.symbol());
      }
      invoked_events_.emplace(std::make_pair(invoked_events_.size(), event));
      dispatcher_->AddInvokedEvent(std::move(event));
      return true;
    }
    case proto::Event::kOutput: {
      const proto::OutputEvent& content = proto_event.output();
      Thread* thread = dispatcher_->SearchThread(content.thread_koid());
      if (thread == nullptr) {
        FX_LOGS(ERROR) << "Thread " << content.thread_koid() << " not found for event.";
        return false;
      }
      Syscall* syscall = dispatcher_->SearchSyscall(content.syscall());
      if (syscall == nullptr) {
        FX_LOGS(ERROR) << "Syscall " << content.syscall() << " not found.";
        return false;
      }
      auto invoked_event = invoked_events_.find(content.invoked_event_id());
      if (invoked_event == invoked_events_.end()) {
        FX_LOGS(ERROR) << "Invoked event " << content.invoked_event_id()
                       << " not found for ouput event.";
        return false;
      }
      auto event = std::make_shared<OutputEvent>(proto_event.timestamp(), thread, syscall,
                                                 content.returned_value(), invoked_event->second);
      if (!DecodeValues(event.get(), content.inline_fields(), content.inline_id_fields(),
                        content.outline_fields(), content.outline_id_fields(),
                        /*invoked=*/false)) {
        return false;
      }
      dispatcher_->AddOutputEvent(std::move(event));
      return true;
    }
    case proto::Event::kException: {
      const proto::ExceptionEvent& content = proto_event.exception();
      Thread* thread = dispatcher_->SearchThread(content.thread_koid());
      if (thread == nullptr) {
        FX_LOGS(ERROR) << "Thread " << content.thread_koid() << " not found for event.";
        return false;
      }
      auto event = std::make_shared<ExceptionEvent>(proto_event.timestamp(), thread);
      for (int index = 0; index < content.frame_size(); ++index) {
        const proto::Location& proto_location = content.frame(index);
        event->stack_frame().emplace_back(proto_location.path(), proto_location.line(),
                                          proto_location.column(), proto_location.address(),
                                          proto_location.symbol());
      }
      dispatcher_->AddExceptionEvent(std::move(event));
      return true;
    }
    default:
      FX_LOGS(ERROR) << "Bad kind for event.";
      return false;
  }
}

bool EventDecoder::DecodeValues(
    SyscallEvent* event,
    const ::google::protobuf::Map<::std::string, ::fidl_codec::proto::Value>& inline_fields,
    const ::google::protobuf::Map<uint32_t, ::fidl_codec::proto::Value>& inline_id_fields,
    const ::google::protobuf::Map<::std::string, ::fidl_codec::proto::Value>& outline_fields,
    const ::google::protobuf::Map<uint32_t, ::fidl_codec::proto::Value>& outline_id_fields,
    bool invoked) {
  bool ok = true;
  for (const auto& proto_value : inline_fields) {
    const fidl_codec::StructMember* member =
        event->syscall()->SearchInlineMember(proto_value.first, invoked);
    if (member == nullptr) {
      FX_LOGS(ERROR) << "Member " << proto_value.first << " not found for "
                     << event->syscall()->name() << '.';
      ok = false;
    } else {
      std::unique_ptr<fidl_codec::Value> value =
          fidl_codec::DecodeValue(dispatcher_->loader(), proto_value.second, member->type());
      if (value == nullptr) {
        ok = false;
      } else {
        event->AddInlineField(member, std::move(value));
      }
    }
  }
  for (const auto& proto_value : inline_id_fields) {
    const fidl_codec::StructMember* member =
        event->syscall()->SearchInlineMember(proto_value.first, invoked);
    if (member == nullptr) {
      FX_LOGS(ERROR) << "Member " << proto_value.first << " not found for "
                     << event->syscall()->name() << '.';
      ok = false;
    } else {
      std::unique_ptr<fidl_codec::Value> value =
          fidl_codec::DecodeValue(dispatcher_->loader(), proto_value.second, member->type());
      if (value == nullptr) {
        ok = false;
      } else {
        event->AddInlineField(member, std::move(value));
      }
    }
  }
  for (const auto& proto_value : outline_fields) {
    const fidl_codec::StructMember* member =
        event->syscall()->SearchOutlineMember(proto_value.first, invoked);
    if (member == nullptr) {
      FX_LOGS(ERROR) << "Member " << proto_value.first << " not found for "
                     << event->syscall()->name() << '.';
      ok = false;
    } else {
      std::unique_ptr<fidl_codec::Value> value =
          fidl_codec::DecodeValue(dispatcher_->loader(), proto_value.second, member->type());
      if (value == nullptr) {
        ok = false;
      } else {
        event->AddOutlineField(member, std::move(value));
      }
    }
  }
  for (const auto& proto_value : outline_id_fields) {
    const fidl_codec::StructMember* member =
        event->syscall()->SearchOutlineMember(proto_value.first, invoked);
    if (member == nullptr) {
      FX_LOGS(ERROR) << "Member " << proto_value.first << " not found for "
                     << event->syscall()->name() << '.';
      ok = false;
    } else {
      std::unique_ptr<fidl_codec::Value> value =
          fidl_codec::DecodeValue(dispatcher_->loader(), proto_value.second, member->type());
      if (value == nullptr) {
        ok = false;
      } else {
        event->AddOutlineField(member, std::move(value));
      }
    }
  }
  return ok;
}

}  // namespace fidlcat