// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/collaboration/internal/collaboration_controller.h"

#include <optional>

#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/scoped_observation.h"
#include "base/strings/stringprintf.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/time.h"
#include "components/collaboration/internal/metrics.h"
#include "components/collaboration/public/collaboration_flow_type.h"
#include "components/collaboration/public/collaboration_utils.h"
#include "components/data_sharing/public/data_sharing_service.h"
#include "components/data_sharing/public/group_data.h"
#include "components/data_sharing/public/logger.h"
#include "components/data_sharing/public/logger_common.mojom.h"
#include "components/data_sharing/public/logger_utils.h"
#include "components/saved_tab_groups/public/saved_tab_group.h"
#include "components/sync/base/collaboration_id.h"
#include "components/sync/service/sync_service.h"

namespace collaboration {

using metrics::CollaborationServiceFlowEvent;
using metrics::CollaborationServiceJoinEvent;
using metrics::CollaborationServiceShareOrManageEvent;

class ControllerState;

namespace {

constexpr char kDebugCollaborationStateString[] =
    "Collaboration State Change\n"
    "  New State: %s\n"
    "  Previous State: %s\n"
    "  Error Type: %s\n";

using ErrorInfo = CollaborationControllerDelegate::ErrorInfo;
using Outcome = CollaborationControllerDelegate::Outcome;
using ResultCallback = CollaborationControllerDelegate::ResultCallback;
using GroupDataOrFailureOutcome =
    data_sharing::DataSharingService::GroupDataOrFailureOutcome;
using StateId = CollaborationController::StateId;
using Flow = CollaborationController::Flow;
using ServiceStatusUpdate = CollaborationService::Observer::ServiceStatusUpdate;

constexpr base::TimeDelta kTimeoutWaitingForDataSharingGroup =
    base::Seconds(20);

std::string GetStateIdString(StateId state) {
  switch (state) {
    case StateId::kPending:
      return "Pending";
    case StateId::kWaitingForPolicyUpdate:
      return "WaitingForPolicyUpdate";
    case StateId::kAuthenticating:
      return "Authenticating";
    case StateId::kWaitingForServicesToInitialize:
      return "WaitingForServicesToInitialize";
    case StateId::kCheckingFlowRequirements:
      return "CheckingFlowRequirements";
    case StateId::kAddingUserToGroup:
      return "AddingUserToGroup";
    case StateId::kWaitingForSyncAndDataSharingGroup:
      return "WaitingForSyncAndDataSharingGroup";
    case StateId::kOpeningLocalTabGroup:
      return "OpeningLocalTabGroup";
    case StateId::kShowingShareScreen:
      return "ShowingShareScreen";
    case StateId::kMakingTabGroupShared:
      return "MakingTabGroupShared";
    case StateId::kSharingTabGroupUrl:
      return "SharingTabGroupUrl";
    case StateId::kShowingManageScreen:
      return "ShowingManageScreen";
    case CollaborationController::StateId::kLeavingGroup:
      return "LeavingGroup";
    case CollaborationController::StateId::kDeletingGroup:
      return "DeletingGroup";
    case StateId::kCleaningUpSharedTabGroup:
      return "CleaningUpSharedTabGroup";
    case StateId::kCancel:
      return "Cancel";
    case StateId::kError:
      return "Error";
  }
}

std::string CreateStateTransitionLogString(
    StateId previous,
    StateId current,
    const CollaborationControllerDelegate::ErrorInfo& error) {
  std::string error_str =
      error.type() != CollaborationControllerDelegate::ErrorInfo::Type::kUnknown
          ? error.GetLogString()
          : "[N/A]";
  std::string log = base::StringPrintf(kDebugCollaborationStateString,
                                       GetStateIdString(current),
                                       GetStateIdString(previous), error_str);

  return log;
}

}  // namespace

// This is base class for each state and handles the logic for the state.
// TODO(crbug.com/389953812): Consider consolidating metric recording into the
// base class. Provide a utility function to handle state specific metrics.
class ControllerState {
 public:
  ControllerState(StateId id, CollaborationController* controller)
      : id_(id), controller_(controller) {}
  virtual ~ControllerState() = default;

  // Called when entering the state.
  virtual void OnEnter(const ErrorInfo& error) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  }

  // Called to process the outcome of an external event.
  virtual void ProcessOutcome(Outcome outcome) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    switch (outcome) {
      case Outcome::kSuccess:
        OnProcessingFinishedWithSuccess();
        return;
      case Outcome::kCancel:
        controller_->Exit();
        return;
      case Outcome::kFailure:
      // The following outcomes should only be used by specific state.
      case Outcome::kGroupLeftOrDeleted:
        HandleError();
        return;
    }
  }

  // Called when an error happens during the state.
  virtual void HandleError() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->TransitionTo(StateId::kError,
                              ErrorInfo(ErrorInfo::Type::kGenericError));
  }

  virtual void HandleErrorWithMetrics(
      CollaborationServiceJoinEvent event,
      CollaborationServiceFlowEvent flow_event) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordJoinEvent(GetLogger(), event);
    RecordCollaborationFlowEvent(GetLogger(), controller_->flow().type,
                                 flow_event);
    HandleError();
  }

  virtual void HandleErrorWithType(ErrorInfo::Type type) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->TransitionTo(StateId::kError,
                              ErrorInfo(type, controller_->flow().type));
  }

  // Called when the state outcome processing is finished.
  virtual void OnProcessingFinishedWithSuccess() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  }

  // Called when exiting the state.
  virtual void OnExit() { DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); }

  StateId id() const { return id_; }

 protected:
  bool IsTabGroupInSync(const data_sharing::GroupId& group_id) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    const std::vector<tab_groups::SavedTabGroup>& all_groups =
        controller_->tab_group_sync_service()->GetAllGroups();
    for (const auto& group : all_groups) {
      if (group.collaboration_id().has_value() &&
          group.collaboration_id().value() ==
              syncer::CollaborationId(group_id.value())) {
        return true;
      }
    }
    return false;
  }

  std::optional<data_sharing::GroupId> GetGroupIdFromEitherId(
      const tab_groups::EitherGroupID& either_id) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    std::optional<tab_groups::SavedTabGroup> tab_group =
        controller_->tab_group_sync_service()->GetGroup(either_id);

    if (tab_group.has_value() && tab_group->collaboration_id().has_value()) {
      auto group_id = tab_group->collaboration_id().value().value();
      return data_sharing::GroupId(group_id);
    }

    return std::nullopt;
  }

  bool IsPeopleGroupInDataSharing(const data_sharing::GroupId& group_id) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    return controller_->collaboration_service()->GetCurrentUserRoleForGroup(
               group_id) != data_sharing::MemberRole::kUnknown;
  }

  data_sharing::Logger* GetLogger() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    return controller_->data_sharing_service()->GetLogger();
  }

  THREAD_CHECKER(thread_checker_);
  const StateId id_;
  const raw_ptr<CollaborationController> controller_;
  base::WeakPtrFactory<ControllerState> weak_ptr_factory_{this};
};

namespace {

class PendingState : public ControllerState {
 public:
  PendingState(StateId id,
               CollaborationController* controller,
               base::OnceClosure exit_callback)
      : ControllerState(id, controller),
        exit_callback_(std::move(exit_callback)) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

    controller_->delegate()->PrepareFlowUI(
        std::move(exit_callback_),
        base::BindOnce(&PendingState::ProcessOutcome,
                       weak_ptr_factory_.GetWeakPtr()));
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

    if (controller_->flow().type == FlowType::kJoin) {
      // Handle URL parsing errors.
      if (!controller_->flow().join_token().IsValid()) {
        RecordJoinEvent(GetLogger(),
                        CollaborationServiceJoinEvent::kParsingFailure);
        RecordCollaborationFlowEvent(
            GetLogger(), controller_->flow().type,
            CollaborationServiceFlowEvent::kJoinParsingFailure);
        HandleErrorWithType(ErrorInfo::Type::kInvalidUrl);
        return;
      }
    }

    ServiceStatus status =
        controller_->collaboration_service()->GetServiceStatus();
    // Handle disabled by versioning.
    // TODO(haileywang@): Refactor error handling for share/join flows and
    // record metrics.
    if (status.collaboration_status ==
        CollaborationStatus::kVersionOutOfDateShowUpdateChromeUi) {
      HandleErrorWithType(ErrorInfo::Type::kUpdateChromeUiForVersionOutOfDate);
      return;
    }
    // Handle disabled by policy.
    if (status.collaboration_status == CollaborationStatus::kDisabledPending ||
        status.collaboration_status ==
            CollaborationStatus::kDisabledForPolicy) {
      controller_->TransitionTo(StateId::kWaitingForPolicyUpdate);
      return;
    }

    // Verify authentication status.
    if (!status.IsAuthenticationValid()) {
      controller_->TransitionTo(StateId::kAuthenticating);
      return;
    }

    controller_->TransitionTo(StateId::kWaitingForServicesToInitialize);
  }

 private:
  //  Will be invalid after OnEnter() is called.
  base::OnceClosure exit_callback_;
};

class WaitingForPolicyUpdateState : public ControllerState,
                                    public CollaborationService::Observer {
 public:
  WaitingForPolicyUpdateState(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    ServiceStatus status =
        controller_->collaboration_service()->GetServiceStatus();
    if (status.collaboration_status == CollaborationStatus::kDisabledPending) {
      RecordJoinOrShareOrManageEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceJoinEvent::kAccountInfoNotReadyOnSignin,
          CollaborationServiceShareOrManageEvent::kAccountInfoNotReadyOnSignin);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kAccountInfoNotReadyOnSignin);
      pending_status_change_observer_.Observe(
          controller_->collaboration_service());
      return;
    }

    // If neither sign in nor sync has been disabled by the enterprise and the
    // user is not trying to join, allow it.
    bool signin_enabled = status.signin_status != SigninStatus::kSigninDisabled;
    bool sync_enabled =
        status.sync_status != SyncStatus::kSyncDisabledByEnterprise;
    bool is_join_flow = controller_->flow().type == FlowType::kJoin;
    if (signin_enabled && sync_enabled && !is_join_flow) {
      OnProcessingFinishedWithSuccess();
      return;
    }

    HandleError();
  }

  void HandleError() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    ServiceStatus status =
        controller_->collaboration_service()->GetServiceStatus();

    if (status.signin_status == SigninStatus::kSigninDisabled) {
      RecordJoinOrShareOrManageEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceJoinEvent::kDevicePolicyDisableSignin,
          CollaborationServiceShareOrManageEvent::kDevicePolicyDisableSignin);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kDevicePolicyDisableSignin);
      HandleErrorWithType(ErrorInfo::Type::kSigninDisabledByPolicy);
      return;
    }

    RecordJoinOrShareOrManageEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceJoinEvent::kManagedAccountSignin,
        CollaborationServiceShareOrManageEvent::kManagedAccountSignin);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kManagedAccountSignin);

    if (status.sync_status == SyncStatus::kSyncDisabledByEnterprise) {
      HandleErrorWithType(ErrorInfo::Type::kSyncDisabledByPolicy);
    } else if (controller_->flow().type == FlowType::kJoin) {
      HandleErrorWithType(ErrorInfo::Type::kSharingDisabledByPolicy);
    }
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    ServiceStatus status =
        controller_->collaboration_service()->GetServiceStatus();
    if (status.IsAuthenticationValid()) {
      controller_->TransitionTo(StateId::kCheckingFlowRequirements);
      return;
    }
    controller_->TransitionTo(StateId::kAuthenticating);
  }

  // CollaborationService::Observer implementation.
  void OnServiceStatusChanged(const ServiceStatusUpdate& update) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    ServiceStatus status = update.new_status;
    switch (status.collaboration_status) {
      case CollaborationStatus::kDisabledPending:
        break;
      case CollaborationStatus::kDisabled:
      case CollaborationStatus::kDisabledForPolicy:
      case CollaborationStatus::kVersionOutOfDate:
        HandleError();
        break;
      case CollaborationStatus::kVersionOutOfDateShowUpdateChromeUi:
        HandleErrorWithType(
            ErrorInfo::Type::kUpdateChromeUiForVersionOutOfDate);
        break;
      case CollaborationStatus::kAllowedToJoin:
      case CollaborationStatus::kEnabledJoinOnly:
      case CollaborationStatus::kEnabledCreateAndJoin:
        OnProcessingFinishedWithSuccess();
        break;
    }
  }

 private:
  base::ScopedObservation<CollaborationService, CollaborationService::Observer>
      pending_status_change_observer_{this};
};

class AuthenticatingState : public ControllerState,
                            public CollaborationService::Observer {
 public:
  AuthenticatingState(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    start_time_ = base::Time::Now();
    FlowType flow_type = controller_->flow().type;
    RecordJoinOrShareOrManageEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceJoinEvent::kNotSignedIn,
        CollaborationServiceShareOrManageEvent::kNotSignedIn);
    RecordCollaborationFlowEvent(GetLogger(), flow_type,
                                 CollaborationServiceFlowEvent::kNotSignedIn);

    controller_->delegate()->ShowAuthenticationUi(
        flow_type, base::BindOnce(&AuthenticatingState::ProcessOutcome,
                                  local_weak_ptr_factory_.GetWeakPtr()));
  }

  void ProcessOutcome(Outcome outcome) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    if (Outcome::kCancel == outcome) {
      RecordJoinOrShareOrManageEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceJoinEvent::kCanceledNotSignedIn,
          CollaborationServiceShareOrManageEvent::kCanceledNotSignedIn);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kCanceledNotSignedIn);
    }

    ControllerState::ProcessOutcome(outcome);
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    ServiceStatus status =
        controller_->collaboration_service()->GetServiceStatus();
    if (!status.IsAllowedToJoin()) {
      controller_->TransitionTo(StateId::kWaitingForPolicyUpdate);
      return;
    }

    FlowType flow_type = controller_->flow().type;
    if (!status.IsAuthenticationValid()) {
      // Set up the timeout exit task.
      base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
          FROM_HERE,
          base::BindOnce(&AuthenticatingState::HandleError,
                         weak_ptr_factory_.GetWeakPtr()),
          base::Minutes(30));
      collaboration_service_observer_.Observe(
          controller_->collaboration_service());
      RecordJoinOrShareOrManageEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceJoinEvent::kSigninVerificationFailed,
          CollaborationServiceShareOrManageEvent::kSigninVerificationFailed);
      RecordCollaborationFlowEvent(
          GetLogger(), flow_type,
          CollaborationServiceFlowEvent::kSigninVerificationFailed);
      return;
    }

    RecordJoinOrShareOrManageEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceJoinEvent::kSigninVerified,
        CollaborationServiceShareOrManageEvent::kSigninVerified);
    RecordCollaborationFlowEvent(
        GetLogger(), flow_type, CollaborationServiceFlowEvent::kSigninVerified);
    // TODO(crbug.com/380957996): Handle signin/sync changes during a flow.
    FinishAndTransition();
  }

  // CollaborationService::Observer implementation.
  void OnServiceStatusChanged(const ServiceStatusUpdate& update) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    ServiceStatus status = update.new_status;
    if (!status.IsAllowedToJoin()) {
      controller_->TransitionTo(StateId::kWaitingForPolicyUpdate);
      return;
    }

    if (status.IsAuthenticationValid()) {
      RecordJoinOrShareOrManageEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceJoinEvent::kSigninVerifiedInObserver,
          CollaborationServiceShareOrManageEvent::kSigninVerifiedInObserver);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kSigninVerifiedInObserver);
      FinishAndTransition();
    }
  }

 private:
  void FinishAndTransition() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordLatency(
        GetLogger(),
        metrics::CollaborationServiceStep::kAuthenticationInitToSuccess,
        base::Time::Now() - start_time_);
    controller_->delegate()->NotifySignInAndSyncStatusChange();
    controller_->TransitionTo(StateId::kWaitingForServicesToInitialize);
  }

  base::Time start_time_;
  base::ScopedObservation<CollaborationService, CollaborationService::Observer>
      collaboration_service_observer_{this};

  base::WeakPtrFactory<AuthenticatingState> local_weak_ptr_factory_{this};
};

class WaitingForServicesToInitialize
    : public ControllerState,
      public tab_groups::TabGroupSyncService::Observer,
      public data_sharing::DataSharingService::Observer {
 public:
  WaitingForServicesToInitialize(StateId id,
                                 CollaborationController* controller)
      : ControllerState(id, controller) {}

  // ControllerState implementation.
  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    start_time_ = base::Time::Now();
    // Timeout waiting.
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
        FROM_HERE,
        base::BindOnce(
            &WaitingForServicesToInitialize::HandleErrorWithMetrics,
            weak_ptr_factory_.GetWeakPtr(),
            CollaborationServiceJoinEvent::kTimeoutWaitingForServicesReady,
            CollaborationServiceFlowEvent::kJoinTimeoutWaitingForServicesReady),
        base::Seconds(5));
    // TODO(crbug.com/392791204): Wait for tab group sync to be ready.
    is_data_sharing_ready_ =
        controller_->data_sharing_service()->IsGroupDataModelLoaded();
    if (!is_data_sharing_ready_) {
      data_sharing_observer_.Observe(controller_->data_sharing_service());
    } else {
      RecordJoinOrShareOrManageEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceJoinEvent::kDataSharingReadyWhenStarted,
          CollaborationServiceShareOrManageEvent::kDataSharingReadyWhenStarted);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kDataSharingReadyWhenStarted);
    }
    tab_group_sync_observer_.Observe(controller_->tab_group_sync_service());
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordLatency(
        GetLogger(),
        metrics::CollaborationServiceStep::kWaitingForServicesInitialization,
        base::Time::Now() - start_time_);
    controller_->TransitionTo(StateId::kCheckingFlowRequirements);
  }

  // TabGroupSyncService::Observer implementation.
  void OnInitialized() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordJoinOrShareOrManageEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceJoinEvent::kTabGroupServiceReady,
        CollaborationServiceShareOrManageEvent::kTabGroupServiceReady);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kTabGroupServiceReady);
    is_tab_group_sync_ready_ = true;
    MaybeProceed();
  }

  // DataSharingService::Observer implementation.
  void OnGroupDataModelLoaded() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordJoinOrShareOrManageEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceJoinEvent::kDataSharingServiceReadyObserved,
        CollaborationServiceShareOrManageEvent::
            kDataSharingServiceReadyObserved);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kDataSharingServiceReadyObserved);

    is_data_sharing_ready_ = true;
    MaybeProceed();
  }

 private:
  void MaybeProceed() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    if (is_tab_group_sync_ready_ && is_data_sharing_ready_) {
      RecordJoinOrShareOrManageEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceJoinEvent::kAllServicesReadyForFlow,
          CollaborationServiceShareOrManageEvent::kAllServicesReadyForFlow);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kAllServicesReadyForFlow);
      OnProcessingFinishedWithSuccess();
    }
  }

  base::Time start_time_;
  bool is_tab_group_sync_ready_{false};
  bool is_data_sharing_ready_{false};
  base::ScopedObservation<tab_groups::TabGroupSyncService,
                          tab_groups::TabGroupSyncService::Observer>
      tab_group_sync_observer_{this};
  base::ScopedObservation<data_sharing::DataSharingService,
                          data_sharing::DataSharingService::Observer>
      data_sharing_observer_{this};
};

class CheckingFlowRequirementsState : public ControllerState {
 public:
  CheckingFlowRequirementsState(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordJoinOrShareOrManageEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceJoinEvent::kFlowRequirementsMet,
        CollaborationServiceShareOrManageEvent::kFlowRequirementsMet);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kFlowRequirementsMet);
    switch (controller_->flow().type) {
      case FlowType::kJoin:
        CheckJoinFlowRequirements();
        break;
      case FlowType::kShareOrManage:
        CheckShareFlowRequirements();
        break;
      case FlowType::kLeaveOrDelete:
        CheckLeaveOrDeleteFlowRequirements();
        break;
    }
  }

 private:
  void CheckJoinFlowRequirements() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    const data_sharing::GroupId group_id =
        controller_->flow().join_token().group_id;
    // Check if user is already part of the group.
    if (IsPeopleGroupInDataSharing(group_id)) {
      if (IsTabGroupInSync(group_id)) {
        RecordJoinEvent(GetLogger(),
                        CollaborationServiceJoinEvent::kOpenedExistingGroup);
        RecordCollaborationFlowEvent(
            GetLogger(), controller_->flow().type,
            CollaborationServiceFlowEvent::kJoinOpenedExistingGroup);
        controller_->TransitionTo(StateId::kOpeningLocalTabGroup);
        return;
      }

      RecordJoinEvent(
          GetLogger(),
          CollaborationServiceJoinEvent::kFoundCollaborationWithoutTabGroup);
      RecordCollaborationFlowEvent(GetLogger(), controller_->flow().type,
                                   CollaborationServiceFlowEvent::
                                       kJoinFoundCollaborationWithoutTabGroup);
      controller_->TransitionTo(StateId::kWaitingForSyncAndDataSharingGroup);
      return;
    }
    controller_->TransitionTo(StateId::kAddingUserToGroup);
  }

  void CheckShareFlowRequirements() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    std::optional<tab_groups::SavedTabGroup> sync_group =
        controller_->tab_group_sync_service()->GetGroup(
            controller_->flow().either_id());
    if (!sync_group.has_value()) {
      RecordShareOrManageEvent(
          GetLogger(),
          CollaborationServiceShareOrManageEvent::kSyncedTabGroupNotFound);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kSyncedTabGroupNotFound);
      HandleError();
      return;
    }

    if (sync_group.value().is_shared_tab_group()) {
      controller_->TransitionTo(StateId::kShowingManageScreen);
      return;
    }

    controller_->TransitionTo(StateId::kShowingShareScreen);
  }

  void CheckLeaveOrDeleteFlowRequirements() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    auto group_id_opt = GetGroupIdFromEitherId(controller_->flow().either_id());
    if (!group_id_opt.has_value()) {
      HandleError();
      return;
    }
    data_sharing::MemberRole role =
        controller_->collaboration_service()->GetCurrentUserRoleForGroup(
            group_id_opt.value());
    if (role == data_sharing::MemberRole::kMember) {
      controller_->TransitionTo(StateId::kLeavingGroup);
    } else if (role == data_sharing::MemberRole::kOwner) {
      controller_->TransitionTo(StateId::kDeletingGroup);
    } else {
      HandleError();
    }
  }

  base::WeakPtrFactory<CheckingFlowRequirementsState> local_weak_ptr_factory_{
      this};
};

class AddingUserToGroupState : public ControllerState {
 public:
  AddingUserToGroupState(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->data_sharing_service()->ReadNewGroup(
        controller_->flow().join_token(),
        base::BindOnce(
            &AddingUserToGroupState::ProcessGroupDataOrFailureOutcome,
            local_weak_ptr_factory_.GetWeakPtr()));
    controller_->data_sharing_service()->GetSharedEntitiesPreview(
        controller_->flow().join_token(),
        base::BindOnce(
            &AddingUserToGroupState::ProcessSharedDataPreviewOrFailureOutcome,
            local_weak_ptr_factory_.GetWeakPtr()));
  }

  void ProcessOutcome(Outcome outcome) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    CHECK_EQ(controller_->flow().type, FlowType::kJoin)
        << "Only the join flow can transition into the AddingUserToGroup "
           "state.";

    switch (outcome) {
      case Outcome::kSuccess:
        RecordJoinEvent(GetLogger(),
                        CollaborationServiceJoinEvent::kAddedUserToGroup);
        RecordLatency(GetLogger(),
                      metrics::CollaborationServiceStep::kFullJoinFlowSuccess,
                      base::Time::Now() - controller_->flow_start_time());
        RecordCollaborationFlowEvent(
            GetLogger(), controller_->flow().type,
            CollaborationServiceFlowEvent::kJoinAddedUserToGroup);
        break;
      case Outcome::kFailure:
        RecordJoinEvent(
            GetLogger(),
            CollaborationServiceJoinEvent::kFailedAddingUserToGroup);
        RecordCollaborationFlowEvent(
            GetLogger(), controller_->flow().type,
            CollaborationServiceFlowEvent::kJoinFailedAddingUserToGroup);

        break;
      case Outcome::kCancel:
        RecordJoinEvent(GetLogger(), CollaborationServiceJoinEvent::kCanceled);
        RecordCollaborationFlowEvent(
            GetLogger(), controller_->flow().type,
            CollaborationServiceFlowEvent::kJoinCanceled);
        break;
      case Outcome::kGroupLeftOrDeleted:
        NOTREACHED() << "kGroupLeftOrDeleted should not happen in "
                        "AddingUserToGroupState";
    }

    ControllerState::ProcessOutcome(outcome);
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordJoinEvent(GetLogger(), CollaborationServiceJoinEvent::kAccepted);
    RecordCollaborationFlowEvent(GetLogger(), controller_->flow().type,
                                 CollaborationServiceFlowEvent::kJoinAccepted);

    const data_sharing::GroupId group_id =
        controller_->flow().join_token().group_id;
    if (IsTabGroupInSync(group_id) && IsPeopleGroupInDataSharing(group_id)) {
      RecordJoinEvent(GetLogger(),
                      CollaborationServiceJoinEvent::kGroupExistsWhenJoined);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kJoinGroupExistsWhenJoined);
      controller_->TransitionTo(StateId::kOpeningLocalTabGroup);
      return;
    }

    RecordJoinEvent(GetLogger(),
                    CollaborationServiceJoinEvent::kOpenedNewGroup);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kJoinOpenedNewGroup);
    controller_->TransitionTo(StateId::kWaitingForSyncAndDataSharingGroup);
  }

 private:
  void ProcessSharedDataPreviewOrFailureOutcome(
      const data_sharing::DataSharingService::SharedDataPreviewOrFailureOutcome&
          preview_outcome) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    preview_data_ = preview_outcome;
    MaybeProceedJoinFlow();
  }

  // Called to process the outcome of data sharing read event.
  void ProcessGroupDataOrFailureOutcome(
      const GroupDataOrFailureOutcome& group_outcome) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    read_group_data_ = group_outcome;
    MaybeProceedJoinFlow();
  }

  void MaybeProceedJoinFlow() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    // Data sharing outcome is not ready yet.
    if (!preview_data_.has_value() || !read_group_data_.has_value()) {
      return;
    }

    data_sharing::DataSharingService::SharedDataPreviewOrFailureOutcome
        preview_outcome = preview_data_.value();
    GroupDataOrFailureOutcome group_outcome = read_group_data_.value();

    // Check if user is already in group.
    if (group_outcome.has_value()) {
      RecordJoinEvent(GetLogger(),
                      CollaborationServiceJoinEvent::kReadNewGroupSuccess);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kJoinReadNewGroupSuccess);
    }

    if (group_outcome.has_value() &&
        GetCurrentUserRoleForGroup(controller_->identity_manager(),
                                   group_outcome.value()) !=
            data_sharing::MemberRole::kUnknown) {
      RecordJoinEvent(
          GetLogger(),
          CollaborationServiceJoinEvent::kReadNewGroupUserIsAlreadyMember);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kJoinReadNewGroupUserIsAlreadyMember);
      controller_->TransitionTo(StateId::kWaitingForSyncAndDataSharingGroup);
      return;
    }

    // Handle preview failures first.
    if (!preview_outcome.has_value()) {
      switch (preview_outcome.error()) {
        case data_sharing::DataSharingService::DataPreviewActionFailure::
            kGroupFull:
          RecordJoinEvent(
              GetLogger(),
              CollaborationServiceJoinEvent::kPreviewGroupFullError);
          RecordCollaborationFlowEvent(
              GetLogger(), controller_->flow().type,
              CollaborationServiceFlowEvent::kJoinPreviewGroupFullError);
          HandleErrorWithType(ErrorInfo::Type::kGroupFull);
          return;
        case data_sharing::DataSharingService::DataPreviewActionFailure::
            kGroupClosedByOrganizationPolicy:
          HandleErrorWithType(
              ErrorInfo::Type::kGroupClosedByOrganizationPolicy);
          return;
        default:
          break;
      }
    }

    if (!preview_outcome.has_value() ||
        !preview_outcome.value().shared_tab_group_preview.has_value()) {
      RecordJoinEvent(GetLogger(),
                      CollaborationServiceJoinEvent::kPreviewFailure);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kJoinPreviewFailure);
      HandleErrorWithType(ErrorInfo::Type::kInvalidUrl);
      return;
    }

    RecordJoinEvent(GetLogger(),
                    CollaborationServiceJoinEvent::kPreviewSuccess);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kJoinPreviewSuccess);

    // Handle read group failure next.
    if (!group_outcome.has_value()) {
      RecordJoinEvent(GetLogger(),
                      CollaborationServiceJoinEvent::kReadNewGroupFailed);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kJoinReadNewGroupFailed);
      HandleErrorWithType(ErrorInfo::Type::kInvalidUrl);
      return;
    }

    // All checks are successful. Continue the join flow.
    controller_->delegate()->ShowJoinDialog(
        controller_->flow().join_token(), preview_outcome.value(),
        base::BindOnce(&AddingUserToGroupState::ProcessOutcome,
                       local_weak_ptr_factory_.GetWeakPtr()));
  }

  std::optional<
      data_sharing::DataSharingService::SharedDataPreviewOrFailureOutcome>
      preview_data_{std::nullopt};
  std::optional<GroupDataOrFailureOutcome> read_group_data_{std::nullopt};

  base::WeakPtrFactory<AddingUserToGroupState> local_weak_ptr_factory_{this};
};

class WaitingForSyncAndDataSharingGroup
    : public ControllerState,
      public tab_groups::TabGroupSyncService::Observer,
      public data_sharing::DataSharingService::Observer {
 public:
  WaitingForSyncAndDataSharingGroup(StateId id,
                                    CollaborationController* controller)
      : ControllerState(id, controller) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    start_time_ = base::Time::Now();
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
        FROM_HERE,
        base::BindOnce(
            &WaitingForSyncAndDataSharingGroup::HandleErrorWithMetrics,
            weak_ptr_factory_.GetWeakPtr(),
            CollaborationServiceJoinEvent::
                kTimeoutWaitingForSyncAndDataSharingGroup,
            CollaborationServiceFlowEvent::
                kJoinTimeoutWaitingForSyncAndDataSharingGroup),
        kTimeoutWaitingForDataSharingGroup);
  }

  // ControllerState implementation.
  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordLatency(GetLogger(),
                  metrics::CollaborationServiceStep::
                      kTabGroupFetchedAfterPeopleGroupJoined,
                  base::Time::Now() - start_time_);
    controller_->TransitionTo(StateId::kOpeningLocalTabGroup);
  }

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    const data_sharing::GroupId group_id =
        controller_->flow().join_token().group_id;
    bool tab_group_exists = IsTabGroupInSync(group_id);
    bool people_group_exists = IsPeopleGroupInDataSharing(group_id);

    if (tab_group_exists && people_group_exists) {
      OnProcessingFinishedWithSuccess();
      return;
    }

    if (!tab_group_exists) {
      tab_group_sync_observer_.Observe(controller_->tab_group_sync_service());
    }

    if (!people_group_exists) {
      data_sharing_observer_.Observe(controller_->data_sharing_service());
      // Force update data sharing service.
      controller_->data_sharing_service()->ReadGroupDeprecated(
          group_id, base::DoNothing());
    }
  }

  // TabGroupSyncService::Observer implementation.
  void OnTabGroupAdded(const tab_groups::SavedTabGroup& group,
                       tab_groups::TriggerSource source) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    const data_sharing::GroupId group_id =
        controller_->flow().join_token().group_id;
    if (group.is_shared_tab_group() &&
        group.collaboration_id().value() ==
            syncer::CollaborationId(group_id.value()) &&
        IsPeopleGroupInDataSharing(group_id)) {
      RecordJoinEvent(GetLogger(),
                      CollaborationServiceJoinEvent::kTabGroupFetched);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kJoinTabGroupFetched);
      ProcessOutcome(Outcome::kSuccess);
    }
  }

  // DataSharingService::Observer implementation.
  void OnGroupAdded(const data_sharing::GroupData& group_data,
                    const base::Time& event_time) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    const data_sharing::GroupId group_id =
        controller_->flow().join_token().group_id;
    if (group_data.group_token.group_id.value() == group_id.value() &&
        IsTabGroupInSync(group_id)) {
      RecordJoinEvent(GetLogger(),
                      CollaborationServiceJoinEvent::kPeopleGroupFetched);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kJoinPeopleGroupFetched);
      ProcessOutcome(Outcome::kSuccess);
    }
  }

 private:
  base::Time start_time_;
  base::ScopedObservation<tab_groups::TabGroupSyncService,
                          tab_groups::TabGroupSyncService::Observer>
      tab_group_sync_observer_{this};
  base::ScopedObservation<data_sharing::DataSharingService,
                          data_sharing::DataSharingService::Observer>
      data_sharing_observer_{this};
};

class OpeningLocalTabGroupState : public ControllerState {
 public:
  OpeningLocalTabGroupState(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    // Only the join flow has a valid `group_id`.
    CHECK_EQ(controller_->flow().type, FlowType::kJoin);

    RecordJoinEvent(GetLogger(),
                    CollaborationServiceJoinEvent::kPromoteTabGroup);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kJoinPromoteTabGroup);
    controller_->delegate()->PromoteTabGroup(
        controller_->flow().join_token().group_id,
        base::BindOnce(&OpeningLocalTabGroupState::ProcessOutcome,
                       weak_ptr_factory_.GetWeakPtr()));
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->Exit();
  }
};

class ShowingShareScreen : public ControllerState {
 public:
  ShowingShareScreen(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    CHECK_EQ(controller_->flow().type, FlowType::kShareOrManage);
    RecordShareOrManageEvent(
        GetLogger(), CollaborationServiceShareOrManageEvent::kShareDialogShown);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kShareDialogShown);

    controller_->delegate()->ShowShareDialog(
        controller_->flow().either_id(),
        base::BindOnce(&ShowingShareScreen::OnCollaborationIdCreated,
                       local_weak_ptr_factory_.GetWeakPtr()));
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->TransitionTo(StateId::kMakingTabGroupShared);
  }

 private:
  void OnCollaborationIdCreated(
      Outcome outcome,
      std::optional<data_sharing::GroupToken> group_token) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    // TODO(haileywang): The following code imitate old behavior to not break
    // tests. Follow new behavior once all platform adjust to new share
    // behavior.
    if (outcome == Outcome::kFailure) {
      RecordShareOrManageEvent(
          GetLogger(),
          CollaborationServiceShareOrManageEvent::kCollaborationIdMissing);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kCollaborationIdMissing);
      HandleError();
      return;
    }

    if (outcome == Outcome::kCancel) {
      RecordShareOrManageEvent(GetLogger(),
                               CollaborationServiceShareOrManageEvent::
                                   kCollaborationIdShareCanceled);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kCollaborationIdShareCanceled);
      controller_->Exit();
      return;
    }

    if (!group_token) {
      RecordShareOrManageEvent(GetLogger(),
                               CollaborationServiceShareOrManageEvent::
                                   kCollaborationIdEmptyGroupToken);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kCollaborationIdEmptyGroupToken);
      controller_->Exit();
      return;
    }

    if (!group_token.value().IsValid()) {
      RecordShareOrManageEvent(
          GetLogger(),
          CollaborationServiceShareOrManageEvent::kCollaborationIdInvalid);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kCollaborationIdInvalid);
      controller_->Exit();
      return;
    }

    controller_->flow().set_share_token(group_token.value());
    RecordShareOrManageEvent(
        GetLogger(),
        CollaborationServiceShareOrManageEvent::kCollaborationGroupCreated);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kCollaborationGroupCreated);
    ProcessOutcome(outcome);
  }

  base::WeakPtrFactory<ShowingShareScreen> local_weak_ptr_factory_{this};
};

class MakingTabGroupShared : public ControllerState {
 public:
  MakingTabGroupShared(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    start_time_ = base::Time::Now();
    CHECK_EQ(controller_->flow().type, FlowType::kShareOrManage);

    std::optional<tab_groups::SavedTabGroup> group =
        controller_->tab_group_sync_service()->GetGroup(
            controller_->flow().either_id());
    if (!group.has_value()) {
      RecordShareOrManageEvent(GetLogger(),
                               CollaborationServiceShareOrManageEvent::
                                   kTabGroupMissingBeforeMigration);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kTabGroupMissingBeforeMigration);
      HandleError();
      return;
    }

    const std::optional<tab_groups::LocalTabGroupID>& local_group_id =
        group.value().local_group_id();
    CHECK(local_group_id.has_value());

    const data_sharing::GroupToken& group_token =
        controller_->flow().share_token();

    controller_->tab_group_sync_service()->MakeTabGroupShared(
        local_group_id.value(),
        syncer::CollaborationId(group_token.group_id.value()),
        base::BindOnce(&MakingTabGroupShared::ProcessTabGroupSharingResult,
                       local_weak_ptr_factory_.GetWeakPtr()));

    controller_->data_sharing_service()->ReadGroupDeprecated(
        group_token.group_id,
        base::BindOnce(&MakingTabGroupShared::ProcessGroupDataOrFailureOutcome,
                       local_weak_ptr_factory_.GetWeakPtr()));
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    RecordShareOrManageEvent(
        GetLogger(), CollaborationServiceShareOrManageEvent::kTabGroupShared);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kTabGroupShared);
    controller_->TransitionTo(StateId::kSharingTabGroupUrl);
  }

 private:
  void ProcessTabGroupSharingResult(
      tab_groups::TabGroupSyncService::TabGroupSharingResult result) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    if (result !=
        tab_groups::TabGroupSyncService::TabGroupSharingResult::kSuccess) {
      RecordShareOrManageEvent(
          GetLogger(),
          CollaborationServiceShareOrManageEvent::kMigrationFailure);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kMigrationFailure);
      HandleError();
      return;
    }

    is_make_group_shared_complete_ = true;
    MaybeProceedFlow();
  }

  void ProcessGroupDataOrFailureOutcome(
      const GroupDataOrFailureOutcome& group_outcome) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    if (!group_outcome.has_value()) {
      RecordShareOrManageEvent(
          GetLogger(),
          CollaborationServiceShareOrManageEvent::kReadGroupFailed);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kReadGroupFailed);
      HandleError();
      return;
    }

    is_read_group_complete_ = true;
    MaybeProceedFlow();
  }

  void MaybeProceedFlow() {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    if (is_make_group_shared_complete_ && is_read_group_complete_) {
      RecordLatency(
          GetLogger(),
          metrics::CollaborationServiceStep::kLinkReadyAfterGroupCreation,
          base::Time::Now() - start_time_);
      OnProcessingFinishedWithSuccess();
    }
  }

  base::Time start_time_;
  bool is_make_group_shared_complete_{false};
  bool is_read_group_complete_{false};
  base::WeakPtrFactory<MakingTabGroupShared> local_weak_ptr_factory_{this};
};

class SharingTabGroupUrl : public ControllerState {
 public:
  SharingTabGroupUrl(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    CHECK_EQ(controller_->flow().type, FlowType::kShareOrManage);

    const data_sharing::GroupToken& group_token =
        controller_->flow().share_token();
    data_sharing::GroupData group_data = data_sharing::GroupData();
    group_data.group_token = group_token;

    auto url =
        controller_->data_sharing_service()->GetDataSharingUrl(group_data);
    if (!url) {
      RecordShareOrManageEvent(
          GetLogger(),
          CollaborationServiceShareOrManageEvent::kUrlCreationFailed);
      RecordCollaborationFlowEvent(
          GetLogger(), controller_->flow().type,
          CollaborationServiceFlowEvent::kUrlCreationFailed);
      HandleError();
      return;
    }

    RecordShareOrManageEvent(
        GetLogger(), CollaborationServiceShareOrManageEvent::kUrlReadyToShare);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kUrlReadyToShare);
    controller_->delegate()->OnUrlReadyToShare(
        group_token.group_id, *url,
        base::BindOnce(&SharingTabGroupUrl::ProcessOutcome,
                       weak_ptr_factory_.GetWeakPtr()));
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

    controller_->Exit();
  }
};

class ManageGroupControllerState : public ControllerState {
 public:
  ManageGroupControllerState(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void ProcessOutcome(Outcome outcome) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    switch (outcome) {
      case Outcome::kGroupLeftOrDeleted:
        controller_->TransitionTo(StateId::kCleaningUpSharedTabGroup);
        return;
      default:
        ControllerState::ProcessOutcome(outcome);
        return;
    }
  }
};

class ShowingManageScreen : public ManageGroupControllerState {
 public:
  ShowingManageScreen(StateId id, CollaborationController* controller)
      : ManageGroupControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    CHECK_EQ(controller_->flow().type, FlowType::kShareOrManage);
    RecordShareOrManageEvent(
        GetLogger(),
        CollaborationServiceShareOrManageEvent::kManageDialogShown);
    RecordCollaborationFlowEvent(
        GetLogger(), controller_->flow().type,
        CollaborationServiceFlowEvent::kManageDialogShown);

    controller_->delegate()->ShowManageDialog(
        controller_->flow().either_id(),
        base::BindOnce(&ShowingManageScreen::ProcessOutcome,
                       local_weak_ptr_factory_.GetWeakPtr()));
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->Exit();
  }

 private:
  base::WeakPtrFactory<ShowingManageScreen> local_weak_ptr_factory_{this};
};

class LeavingGroupState : public ManageGroupControllerState {
 public:
  LeavingGroupState(StateId id, CollaborationController* controller)
      : ManageGroupControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->delegate()->ShowLeaveDialog(
        controller_->flow().either_id(),
        base::BindOnce(&LeavingGroupState::ProcessOutcome,
                       local_weak_ptr_factory_.GetWeakPtr()));
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    auto group_id_opt = GetGroupIdFromEitherId(controller_->flow().either_id());
    if (!group_id_opt.has_value()) {
      HandleError();
      return;
    }
    controller_->data_sharing_service()->LeaveGroup(
        group_id_opt.value(),
        base::BindOnce(&LeavingGroupState::ProcessPeopleGroupActionOutcome,
                       local_weak_ptr_factory_.GetWeakPtr()));
  }

 private:
  void ProcessPeopleGroupActionOutcome(
      data_sharing::DataSharingService::PeopleGroupActionOutcome outcome) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    if (outcome ==
        data_sharing::DataSharingService::PeopleGroupActionOutcome::kSuccess) {
      controller_->TransitionTo(StateId::kCleaningUpSharedTabGroup);
      return;
    }

    HandleError();
  }

  base::WeakPtrFactory<LeavingGroupState> local_weak_ptr_factory_{this};
};

class DeletingGroupState : public ManageGroupControllerState {
 public:
  DeletingGroupState(StateId id, CollaborationController* controller)
      : ManageGroupControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->delegate()->ShowDeleteDialog(
        controller_->flow().either_id(),
        base::BindOnce(&DeletingGroupState::ProcessOutcome,
                       local_weak_ptr_factory_.GetWeakPtr()));
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    auto group_id_opt = GetGroupIdFromEitherId(controller_->flow().either_id());
    if (!group_id_opt.has_value()) {
      HandleError();
      return;
    }
    controller_->data_sharing_service()->DeleteGroup(
        group_id_opt.value(),
        base::BindOnce(&DeletingGroupState::ProcessPeopleGroupActionOutcome,
                       local_weak_ptr_factory_.GetWeakPtr()));
  }

 private:
  void ProcessPeopleGroupActionOutcome(
      data_sharing::DataSharingService::PeopleGroupActionOutcome outcome) {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    if (outcome ==
        data_sharing::DataSharingService::PeopleGroupActionOutcome::kSuccess) {
      controller_->TransitionTo(StateId::kCleaningUpSharedTabGroup);
      return;
    }

    HandleError();
  }

  base::WeakPtrFactory<DeletingGroupState> local_weak_ptr_factory_{this};
};

class CleaningUpSharedTabGroupState : public ControllerState {
 public:
  CleaningUpSharedTabGroupState(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    auto group_id_opt = GetGroupIdFromEitherId(controller_->flow().either_id());
    if (!group_id_opt.has_value()) {
      HandleError();
      return;
    }
    data_sharing::GroupId group_id = group_id_opt.value();

    controller_->tab_group_sync_service()->OnCollaborationRemoved(
        syncer::CollaborationId(group_id.value()));
    controller_->data_sharing_service()->OnCollaborationGroupRemoved(group_id);
    OnProcessingFinishedWithSuccess();
  }

  void OnProcessingFinishedWithSuccess() override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->Exit();
  }
};

class ErrorState : public ControllerState {
 public:
  ErrorState(StateId id, CollaborationController* controller)
      : ControllerState(id, controller) {}

  void OnEnter(const ErrorInfo& error) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->delegate()->ShowError(
        error, base::BindOnce(&ErrorState::ProcessOutcome,
                              local_weak_ptr_factory_.GetWeakPtr()));
  }

  void ProcessOutcome(Outcome outcome) override {
    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
    controller_->Exit();
  }

 private:
  base::WeakPtrFactory<ErrorState> local_weak_ptr_factory_{this};
};

}  // namespace

CollaborationController::Flow::Flow(FlowType type,
                                    const data_sharing::GroupToken& token)
    : type(type), join_token_(token) {
  DCHECK(type == FlowType::kJoin);
}

CollaborationController::Flow::Flow(FlowType type,
                                    const tab_groups::EitherGroupID& either_id)
    : type(type), either_id_(either_id) {}

CollaborationController::Flow::Flow(const Flow&) = default;

CollaborationController::Flow::~Flow() = default;

CollaborationController::CollaborationController(
    const Flow& flow,
    CollaborationService* collaboration_service,
    data_sharing::DataSharingService* data_sharing_service,
    tab_groups::TabGroupSyncService* tab_group_sync_service,
    syncer::SyncService* sync_service,
    signin::IdentityManager* identity_manager,
    std::unique_ptr<CollaborationControllerDelegate> delegate,
    FinishCallback finish_and_delete)
    : flow_(flow),
      collaboration_service_(collaboration_service),
      data_sharing_service_(data_sharing_service),
      tab_group_sync_service_(tab_group_sync_service),
      sync_service_(sync_service),
      identity_manager_(identity_manager),
      delegate_(std::move(delegate)),
      finish_and_delete_(std::move(finish_and_delete)) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  tab_group_sync_service_observer_.Observe(tab_group_sync_service_);
  collaboration_service_observer_.Observe(collaboration_service_);

  flow_start_time_ = base::Time::Now();

  RecordJoinOrShareOrManageEvent(
      data_sharing_service_->GetLogger(), flow_.type,
      CollaborationServiceJoinEvent::kStarted,
      CollaborationServiceShareOrManageEvent::kStarted);
  RecordCollaborationFlowEvent(data_sharing_service_->GetLogger(), flow_.type,
                               CollaborationServiceFlowEvent::kStarted);
  current_state_ = std::make_unique<PendingState>(
      StateId::kPending, this,
      base::BindOnce(&CollaborationController::Exit,
                     weak_ptr_factory_.GetWeakPtr()));

  // Post task to start the flow. This is to make sure all the conflicting flows
  // have exited and cleaned up.
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE, base::BindOnce(&CollaborationController::Start,
                                weak_ptr_factory_.GetWeakPtr()));
}

CollaborationController::~CollaborationController() {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
}

void CollaborationController::TransitionTo(StateId state,
                                           const ErrorInfo& error) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  VLOG(2) << "Transition from " << GetStateIdString(current_state_->id())
          << " to " << GetStateIdString(state);
  DATA_SHARING_LOG(
      logger_common::mojom::LogSource::CollaborationService,
      data_sharing_service()->GetLogger(),
      CreateStateTransitionLogString(current_state_->id(), state, error));
  DCHECK(IsValidStateTransition(current_state_->id(), state));
  current_state_->OnExit();
  current_state_ = CreateStateObject(state);
  current_state_->OnEnter(error);
}

void CollaborationController::PromoteCurrentSession() {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  delegate_->PromoteCurrentScreen();
}

void CollaborationController::Exit() {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  if (is_deleting_) {
    // Exit can be triggered by multiple code paths, the delegate itself, or
    // from the service. It is safe to ignore multiple requets since we are just
    // waiting for finish_and_delete_ to run in the next post task.
    return;
  }

  // Transition to the cancel state while waiting for full deletion.
  if (current_state_->id() != StateId::kCancel) {
    TransitionTo(StateId::kCancel);
  }
  delegate_->OnFlowFinished();
  is_deleting_ = true;
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE, base::BindOnce(std::move(finish_and_delete_), this));
}

void CollaborationController::Cancel() {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  if (is_deleting_) {
    // Cancel can be triggered due to identity manager and tab group changes.
    return;
  }

  delegate()->Cancel(base::IgnoreArgs<Outcome>(base::BindOnce(
      &CollaborationController::Exit, weak_ptr_factory_.GetWeakPtr())));
}

void CollaborationController::SetStateForTesting(StateId state) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  current_state_ = CreateStateObject(state);
  current_state_->OnEnter(ErrorInfo());
}

CollaborationController::StateId CollaborationController::GetStateForTesting() {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  return current_state_->id();
}

void CollaborationController::OnTabGroupRemoved(
    const tab_groups::LocalTabGroupID& local_id,
    tab_groups::TriggerSource source) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  // OnTabGroupRemoved() with sync ID cancels the flow for tab group if it was
  // started with sync ID.
  CancelShareOrManageFlow(local_id);
}

void CollaborationController::OnTabGroupRemoved(
    const base::Uuid& sync_id,
    tab_groups::TriggerSource source) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  // OnTabGroupRemoved() with local ID cancels the flow for tab group if it was
  // started with local ID.
  CancelShareOrManageFlow(sync_id);
}

void CollaborationController::OnTabGroupMigrated(
    const tab_groups::SavedTabGroup& new_group,
    const base::Uuid& old_sync_id,
    tab_groups::TriggerSource source) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  if (new_group.is_shared_tab_group()) {
    // The group is shared, no action needed.
    return;
  }

  // Cancel only works when the EitherGroupID variant matches the provided ID,
  // so try cancelling with both sync ID and local ID.
  CancelShareOrManageFlow(old_sync_id);
  if (new_group.local_group_id().has_value()) {
    CancelShareOrManageFlow(new_group.local_group_id().value());
  }
}

void CollaborationController::OnServiceStatusChanged(
    const ServiceStatusUpdate& update) {
  // If the Shared Tab Groups feature, sync or signin got disabled by an
  // enterprise policy while this flow is active, cancel the current flow and
  // show an error.
  if (update.old_status.collaboration_status !=
          CollaborationStatus::kDisabledForPolicy &&
      update.new_status.collaboration_status ==
          CollaborationStatus::kDisabledForPolicy) {
    if (update.new_status.signin_status == SigninStatus::kSigninDisabled) {
      current_state_->HandleErrorWithType(
          ErrorInfo::Type::kSigninDisabledByPolicy);
    } else if (update.new_status.sync_status ==
               SyncStatus::kSyncDisabledByEnterprise) {
      current_state_->HandleErrorWithType(
          ErrorInfo::Type::kSyncDisabledByPolicy);
    } else {
      current_state_->HandleErrorWithType(
          ErrorInfo::Type::kSharingDisabledByPolicy);
    }
  }
}

void CollaborationController::CancelShareOrManageFlow(
    const tab_groups::EitherGroupID& either_id) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  if (flow_.type == FlowType::kShareOrManage &&
      flow_.either_id() == either_id) {
    if (current_state_->id() == StateId::kCleaningUpSharedTabGroup) {
      // Cleanup will cause the TabGroupRemoved event to be observed. It is safe
      // to ignore.
      return;
    }
    Cancel();
  }
}

bool CollaborationController::IsValidStateTransition(StateId from, StateId to) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  return std::find(kValidTransitions.begin(), kValidTransitions.end(),
                   std::make_pair(from, to)) != std::end(kValidTransitions);
}

std::unique_ptr<ControllerState> CollaborationController::CreateStateObject(
    StateId state) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  switch (state) {
    case StateId::kPending:
      return std::make_unique<PendingState>(state, this, base::DoNothing());
    case StateId::kWaitingForPolicyUpdate:
      return std::make_unique<WaitingForPolicyUpdateState>(state, this);
    case StateId::kAuthenticating:
      return std::make_unique<AuthenticatingState>(state, this);
    case StateId::kWaitingForServicesToInitialize:
      return std::make_unique<WaitingForServicesToInitialize>(state, this);
    case StateId::kCheckingFlowRequirements:
      return std::make_unique<CheckingFlowRequirementsState>(state, this);
    case StateId::kAddingUserToGroup:
      return std::make_unique<AddingUserToGroupState>(state, this);
    case StateId::kWaitingForSyncAndDataSharingGroup:
      return std::make_unique<WaitingForSyncAndDataSharingGroup>(state, this);
    case StateId::kOpeningLocalTabGroup:
      return std::make_unique<OpeningLocalTabGroupState>(state, this);
    case StateId::kShowingShareScreen:
      return std::make_unique<ShowingShareScreen>(state, this);
    case StateId::kMakingTabGroupShared:
      return std::make_unique<MakingTabGroupShared>(state, this);
    case StateId::kSharingTabGroupUrl:
      return std::make_unique<SharingTabGroupUrl>(state, this);
    case StateId::kShowingManageScreen:
      return std::make_unique<ShowingManageScreen>(state, this);
    case StateId::kLeavingGroup:
      return std::make_unique<LeavingGroupState>(state, this);
    case StateId::kDeletingGroup:
      return std::make_unique<DeletingGroupState>(state, this);
    case StateId::kCleaningUpSharedTabGroup:
      return std::make_unique<CleaningUpSharedTabGroupState>(state, this);
    case StateId::kCancel:
      return std::make_unique<ControllerState>(state, this);
    case StateId::kError:
      return std::make_unique<ErrorState>(state, this);
  }
}

void CollaborationController::Start() {
  current_state_->OnEnter(ErrorInfo());
}

}  // namespace collaboration