// Copyright (c) 2020 The Orbit 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 "SessionSetup/SessionSetupDialog.h"

#include <absl/flags/flag.h>

#include <QButtonGroup>

#include <QHistoryState>

#include <QNonConstOverload>

#include <QObject>

#include <QPushButton>

#include <QRadioButton>

#include <QSet>

#include <QWidget>

#include <Qt>

#include <memory>

#include <optional>

#include <string>

#include <utility>

#include <variant>

#include "ClientFlags/ClientFlags.h"

#include "GrpcProtos/process.pb.h"

#include "OrbitBase/Logging.h"

#include "OrbitBase/Result.h"

#include "SessionSetup/ConnectToLocalWidget.h"

#include "SessionSetup/Connections.h"

#include "SessionSetup/LoadCaptureWidget.h"

#include "SessionSetup/OrbitServiceInstance.h"

#include "SessionSetup/ProcessListWidget.h"

#include "SessionSetup/TargetConfiguration.h"

#include "SessionSetup/TargetLabel.h"

#include "ui_SessionSetupDialog.h"

namespace orbit_session_setup {

using orbit_grpc_protos::ProcessInfo;

SessionSetupDialog::SessionSetupDialog(SshConnectionArtifacts* ssh_connection_artifacts,

std::optional<TargetConfiguration> target_configuration_opt,

QWidget* parent)

: QDialog{parent, Qt::Window},

ui_(std::make_unique<Ui::SessionSetupDialog>()),

state_file_(&state_machine_),

state_file_history_(&state_file_),

state_file_selected_(&state_file_),

state_file_no_selection_(&state_file_),

state_local_(&state_machine_),

state_local_history_(&state_local_),

state_local_connecting_(&state_local_),

state_local_connected_(&state_local_),

state_local_no_process_selected_(&state_local_connected_),

state_local_process_selected_(&state_local_connected_) {

ORBIT_CHECK(ssh_connection_artifacts != nullptr);

ui_->setupUi(this);

ui_->localProfilingWidget->SetOrbitServiceInstanceCreateFunction(

[]() { return OrbitServiceInstance::CreatePrivileged(); });

state_machine_.setGlobalRestorePolicy(QStateMachine::RestoreProperties);

SetupFileStates();

SetupLocalStates();

QObject::connect(ui_->confirmButton, &QPushButton::clicked, this, &QDialog::accept);

QObject::connect(ui_->loadCaptureWidget, &LoadCaptureWidget::FileSelected, this,

[this](std::filesystem::path path) { selected_file_path_ = std::move(path); });

QObject::connect(ui_->loadCaptureWidget, &LoadCaptureWidget::SelectionConfirmed, this,

&QDialog::accept);

QObject::connect(ui_->processListWidget, &ProcessListWidget::ProcessSelected, ui_->targetLabel,

qOverload<const ProcessInfo&>(&TargetLabel::ChangeToLocalTarget));

QObject::connect(ui_->processListWidget, &ProcessListWidget::ProcessSelectionCleared,

ui_->targetLabel, &TargetLabel::Clear);

QObject::connect(ui_->processListWidget, &ProcessListWidget::ProcessConfirmed, this,

&QDialog::accept);

button_group_.addButton(ui_->localProfilingWidget->GetRadioButton());

button_group_.addButton(ui_->loadCaptureWidget->GetRadioButton());

if (target_configuration_opt.has_value()) {

TargetConfiguration config = std::move(target_configuration_opt.value());

target_configuration_opt = std::nullopt;

std::visit([this](auto&& target) { SetTargetAndStateMachineInitialState(std::move(target)); },

config);

} else {

state_machine_.setInitialState(&state_local_);

ui_->localProfilingWidget->GetRadioButton()->setChecked(true);

ui_->processListWidget->SetProcessNameToSelect(absl::GetFlag(FLAGS_process_name));

}

}

SessionSetupDialog::~SessionSetupDialog() = default;

std::optional<TargetConfiguration> SessionSetupDialog::Exec() {

state_machine_.start();

int rc = QDialog::exec();

state_machine_.stop();

if (rc != QDialog::Accepted) return std::nullopt;

if (state_machine_.configuration().contains(&state_local_)) {

std::optional<ProcessInfo> process_info_opt = ui_->processListWidget->GetSelectedProcess();

ORBIT_CHECK(process_info_opt.has_value());

return LocalTarget(ui_->localProfilingWidget->TakeConnection(), process_info_opt.value());

}

if (state_machine_.configuration().contains(&state_file_)) {

return FileTarget(selected_file_path_);

}

ORBIT_UNREACHABLE();

return std::nullopt;

}

void SessionSetupDialog::SetupLocalStates() {

// Setup initial and default

state_local_.setInitialState(&state_local_connecting_);

state_local_history_.setDefaultState(&state_local_connecting_);

state_local_connected_.setInitialState(&state_local_no_process_selected_);

// PROPERTIES

// STATE state_local_

state_local_.assignProperty(ui_->confirmButton, "enabled", false);

state_local_.assignProperty(

ui_->confirmButton, "toolTip",

"Please have a OrbitService run on the local machine and select a process.");

// STATE state_local_process_selected_

state_local_process_selected_.assignProperty(ui_->confirmButton, "enabled", true);

state_local_process_selected_.assignProperty(ui_->confirmButton, "toolTip", "");

// TRANSITIONS (and entered/exit events)

// STATE state_local_

state_local_.addTransition(ui_->loadCaptureWidget->GetRadioButton(), &QRadioButton::clicked,

&state_file_history_);

// STATE state_local_connecting_

state_local_connecting_.addTransition(ui_->localProfilingWidget, &ConnectToLocalWidget::Connected,

&state_local_connected_);

// STATE state_local_connected_

state_local_connected_.addTransition(

ui_->localProfilingWidget, &ConnectToLocalWidget::Disconnected, &state_local_connecting_);

QObject::connect(&state_local_connected_, &QState::entered, this,

&SessionSetupDialog::ConnectLocalAndProcessWidget);

QObject::connect(&state_local_connected_, &QState::exited, this,

&SessionSetupDialog::DisconnectLocalAndProcessWidget);

// STATE state_local_no_process_selected_

state_local_no_process_selected_.addTransition(

ui_->processListWidget, &ProcessListWidget::ProcessSelected, &state_local_process_selected_);

// STATE state_local_process_selected_

state_local_process_selected_.addTransition(ui_->processListWidget,

&ProcessListWidget::ProcessSelectionCleared,

&state_local_no_process_selected_);

}

void SessionSetupDialog::SetupFileStates() {

// Setup initial and default

state_file_.setInitialState(&state_file_no_selection_);

state_file_history_.setDefaultState(&state_file_no_selection_);

// PROPERTIES

// STATE state_file_

state_file_.assignProperty(ui_->confirmButton, "enabled", false);

state_file_.assignProperty(ui_->confirmButton, "toolTip", "Please select a capture to load");

state_file_.assignProperty(ui_->processListWidget, "enabled", false);

// STATE state_file_selected_

state_file_selected_.assignProperty(ui_->confirmButton, "enabled", true);

state_file_selected_.assignProperty(ui_->confirmButton, "toolTip", "");

// TRANSITIONS (and entered/exit events)

// STATE state_file_

state_file_.addTransition(ui_->localProfilingWidget->GetRadioButton(), &QRadioButton::clicked,

&state_local_history_);

state_file_.addTransition(ui_->loadCaptureWidget, &LoadCaptureWidget::FileSelected,

&state_file_selected_);

// STATE state_file_selected_

QObject::connect(&state_file_selected_, &QState::entered, this,

[this] { ui_->targetLabel->ChangeToFileTarget(selected_file_path_); });

QObject::connect(&state_file_selected_, &QState::exited, ui_->targetLabel, &TargetLabel::Clear);

}

void SessionSetupDialog::ConnectLocalAndProcessWidget() {

QObject::connect(ui_->localProfilingWidget, &ConnectToLocalWidget::ProcessListUpdated,

ui_->processListWidget, &ProcessListWidget::UpdateList);

}

void SessionSetupDialog::DisconnectLocalAndProcessWidget() {

ui_->processListWidget->Clear();

QObject::disconnect(ui_->localProfilingWidget, &ConnectToLocalWidget::ProcessListUpdated,

ui_->processListWidget, &ProcessListWidget::UpdateList);

}

void SessionSetupDialog::SetTargetAndStateMachineInitialState(SshTarget /*target*/) {

ORBIT_FATAL("not implemented");

}

void SessionSetupDialog::SetTargetAndStateMachineInitialState(LocalTarget target) {

ui_->processListWidget->SetProcessNameToSelect(target.process_.name());

ui_->localProfilingWidget->SetConnection(std::move(target.connection_));

ui_->localProfilingWidget->GetRadioButton()->setChecked(true);

state_local_.setInitialState(&state_local_connected_);

state_local_history_.setDefaultState(&state_local_connected_);

state_machine_.setInitialState(&state_local_);

}

void SessionSetupDialog::SetTargetAndStateMachineInitialState(const FileTarget& target) {

ui_->loadCaptureWidget->GetRadioButton()->setChecked(true);

selected_file_path_ = target.GetCaptureFilePath();

state_file_.setInitialState(&state_file_selected_);

state_file_history_.setDefaultState(&state_file_selected_);

state_machine_.setInitialState(&state_file_);

}

} // namespace orbit_session_setup