// Copyright 2026 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 "src/developer/debug/zxdb/client/until_process_controller.h"

#include <lib/syslog/cpp/macros.h>

#include "src/developer/debug/zxdb/client/breakpoint.h"
#include "src/developer/debug/zxdb/client/breakpoint_settings.h"
#include "src/developer/debug/zxdb/client/process.h"
#include "src/developer/debug/zxdb/client/session.h"
#include "src/developer/debug/zxdb/client/system.h"
#include "src/developer/debug/zxdb/client/thread.h"
#include "src/developer/debug/zxdb/client/until_thread_controller.h"

namespace zxdb {

ProcessUntilThreadController::ProcessUntilThreadController(fxl::WeakPtr<Process> process,
                                                           std::vector<InputLocation> locations,
                                                           fit::callback<void(const Err&)> cb)
    : process_(std::move(process)), weak_factory_(this) {
  if (!process_) {
    cb(Err("No process."));
    return;
  }

  // To handle newly spawned threads.
  session_ = process_->session()->GetWeakPtr();
  session_->thread_observers().AddObserver(this);
  BreakpointSettings settings;
  settings.scope = ExecutionScope(process_->GetTarget());
  settings.locations = std::move(locations);

  // Default value of the original run_until.
  settings.one_shot = true;

  breakpoint_ = process_->session()->system().CreateNewInternalBreakpoint()->GetWeakPtr();
  breakpoint_->SetSettings(settings, [weak_this = weak_factory_.GetWeakPtr(),
                                      cb = std::move(cb)](const Err& err) mutable {
    if (weak_this)
      weak_this->OnBreakpointSetComplete(err, std::move(cb));
  });
}

ProcessUntilThreadController::~ProcessUntilThreadController() {
  if (session_)
    session_->thread_observers().RemoveObserver(this);

  if (breakpoint_ && session_)
    session_->system().DeleteBreakpoint(breakpoint_.get());
}

// Registers the controller to the newly created thread in case this newly created thread is the
// one that actually runs through the breakpoint in the future.
void ProcessUntilThreadController::DidCreateThread(Thread* thread) {
  if (breakpoint_ && process_ && thread->GetProcess() == process_.get()) {
    auto worker =
        std::make_unique<UntilThreadController>(fxl::RefPtr<ProcessUntilThreadController>(this));
    // No need to resume.
    thread->AddController(std::move(worker), {});
  }
}

void ProcessUntilThreadController::AddWorker(fxl::WeakPtr<UntilThreadController> worker) {
  workers_.push_back(std::move(worker));
}

void ProcessUntilThreadController::OnThreadHitBreakpoint(Thread* thread) {
  FX_CHECK(breakpoint_ && process_);
  // The first thread to call this function.
  process_->session()->system().DeleteBreakpoint(breakpoint_.get());
  breakpoint_.reset();

  // Proactively cancel all other worker controllers.
  for (const auto& worker : workers_) {
    if (worker && worker->thread() != thread) {
      worker->Cancel();
    }
  }
}

void ProcessUntilThreadController::OnBreakpointSetComplete(
    const Err& err, fit::callback<void(const Err&)> cb) const {
  if (err.has_error())
    return cb(err);  // Error updating breakpoint.
  const std::vector<BreakpointLocation*> locs = breakpoint_->GetLocations();
  if (locs.empty()) {
    cb(Err("Destination to run until matched no location."));
  } else {
    cb(Err());
  }
}

}  // namespace zxdb