// Copyright 2018 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.

#ifndef SRC_DEVELOPER_DEBUG_ZXDB_CLIENT_TARGET_H_
#define SRC_DEVELOPER_DEBUG_ZXDB_CLIENT_TARGET_H_

#include <map>
#include <string>
#include <vector>

#include "lib/fit/function.h"
#include "src/developer/debug/ipc/protocol.h"
#include "src/developer/debug/zxdb/client/client_object.h"
#include "src/developer/debug/zxdb/client/map_setting_store.h"
#include "src/lib/fxl/macros.h"
#include "src/lib/fxl/memory/weak_ptr.h"
#include "src/lib/fxl/observer_list.h"

namespace zxdb {

class Err;
class Process;
class System;
class TargetSymbols;

// A Target represents the abstract idea of a process that can be debugged. This is as opposed to a
// Process which corresponds to one running process.
//
// Targets are not initially attached to Processes on the debugged device. There are multiple ways
// of associating a Target with a Process.
//
// If users want to start a new process on the debugged device, they set the breakpoints, process
// name, command line switches, and other state in the Target.  The user then runs the target, which
// creates the associated Process object. When the process exits, the Target can be re-used to
// launch the process again with the same configuration.
//
// If users want to associate a Target with a process on the debugged device, they create a new
// Target (possibly using System::CreateNewTarget), and then call Attach() to perform the
// association.
class Target : public ClientObject {
 public:
  // Note that the callback will be issued in all cases which may be after the target is destroyed.
  // In this case the weak pointer will be null.
  using Callback = fit::callback<void(fxl::WeakPtr<Target> target, const Err&)>;
  using CallbackWithTimestamp =
      fit::callback<void(fxl::WeakPtr<Target> target, const Err&, uint64_t timestamp)>;

  enum State {
    // There is no process currently running. From here, it can only transition to starting.
    kNone,

    // A pending state when the process has been requested to be started but there is no reply from
    // the debug agent yet. From here, it can transition to running (success) or stopped (if
    // launching or attaching failed).
    kStarting,

    // A pending state like starting but when we're waiting to attach.
    kAttaching,

    // The process is running. From here, it can only transition to stopped.
    kRunning
  };

  ~Target() override;

  fxl::WeakPtr<Target> GetWeakPtr();

  // Returns the current process state.
  virtual State GetState() const = 0;

  // Returns the process object if it is currently running (see GetState()). Returns null otherwise.
  virtual Process* GetProcess() const = 0;

  // Returns the process-independent symbol interface. See also Process:GetSymbols().
  virtual const TargetSymbols* GetSymbols() const = 0;

  // Sets and retrieves the arguments passed to the program. args[0] is the program name, the rest
  // of the array are the command-line.
  virtual const std::vector<std::string>& GetArgs() const = 0;
  virtual void SetArgs(std::vector<std::string> args) = 0;

  // Launches the program. The program must be in a kStopped state and the program name configured
  // via SetArgs().
  virtual void Launch(CallbackWithTimestamp callback) = 0;

  // Kills the process with the given koid. The callback will be executed when the kill is complete
  // (or fails).
  virtual void Kill(Callback callback) = 0;

  // Attaches to the process with the given koid. The callback will be executed when the attach is
  // complete (or fails).
  virtual void Attach(uint64_t koid, CallbackWithTimestamp callback) = 0;

  // Detaches from the process with the given koid. The callback will be executed when the detach is
  // complete (or fails).
  virtual void Detach(Callback callback) = 0;

  // Notification from the agent that a process has exited.
  virtual void OnProcessExiting(int return_code, uint64_t timestamp) = 0;

  // Provides the setting schema for this object.
  static fxl::RefPtr<SettingSchema> GetSchema();

  MapSettingStore& settings() { return settings_; }

 protected:
  explicit Target(Session* session);

  MapSettingStore settings_;

 private:
  fxl::WeakPtrFactory<Target> weak_factory_;

  FXL_DISALLOW_COPY_AND_ASSIGN(Target);
};

}  // namespace zxdb

#endif  // SRC_DEVELOPER_DEBUG_ZXDB_CLIENT_TARGET_H_