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

#include "chromeos/ash/components/phonehub/tether_controller_impl.h"

#include "chromeos/ash/components/multidevice/logging/logging.h"
#include "chromeos/ash/components/phonehub/phone_status_model.h"
#include "chromeos/ash/components/phonehub/user_action_recorder.h"
#include "chromeos/ash/components/phonehub/util/histogram_util.h"
#include "chromeos/ash/services/network_config/in_process_instance.h"

namespace ash::phonehub {

namespace {

using ::chromeos::network_config::mojom::ConnectionStateType;
using ::chromeos::network_config::mojom::DeviceStatePropertiesPtr;
using ::chromeos::network_config::mojom::FilterType;
using ::chromeos::network_config::mojom::NetworkType;
using ::chromeos::network_config::mojom::StartConnectResult;
using multidevice_setup::MultiDeviceSetupClient;
using multidevice_setup::mojom::Feature;
using multidevice_setup::mojom::FeatureState;

}  // namespace

TetherControllerImpl::TetherNetworkConnector::TetherNetworkConnector() {
  network_config::BindToInProcessInstance(
      cros_network_config_.BindNewPipeAndPassReceiver());
}

TetherControllerImpl::TetherNetworkConnector::~TetherNetworkConnector() =
    default;

void TetherControllerImpl::TetherNetworkConnector::StartConnect(
    const std::string& guid,
    StartConnectCallback callback) {
  cros_network_config_->StartConnect(guid, std::move(callback));
}

void TetherControllerImpl::TetherNetworkConnector::StartDisconnect(
    const std::string& guid,
    StartDisconnectCallback callback) {
  cros_network_config_->StartDisconnect(guid, std::move(callback));
}

void TetherControllerImpl::TetherNetworkConnector::GetNetworkStateList(
    chromeos::network_config::mojom::NetworkFilterPtr filter,
    GetNetworkStateListCallback callback) {
  cros_network_config_->GetNetworkStateList(std::move(filter),
                                            std::move(callback));
}

TetherControllerImpl::TetherControllerImpl(
    PhoneModel* phone_model,
    UserActionRecorder* user_action_recorder,
    MultiDeviceSetupClient* multidevice_setup_client)
    : TetherControllerImpl(
          phone_model,
          user_action_recorder,
          multidevice_setup_client,
          std::make_unique<TetherControllerImpl::TetherNetworkConnector>()) {}

TetherControllerImpl::TetherControllerImpl(
    PhoneModel* phone_model,
    UserActionRecorder* user_action_recorder,
    MultiDeviceSetupClient* multidevice_setup_client,
    std::unique_ptr<TetherControllerImpl::TetherNetworkConnector> connector)
    : phone_model_(phone_model),
      user_action_recorder_(user_action_recorder),
      multidevice_setup_client_(multidevice_setup_client),
      connector_(std::move(connector)) {
  // Receive updates when devices (e.g., Tether, Ethernet, Wi-Fi) go on/offline
  // This class only cares about Tether devices.
  network_config::BindToInProcessInstance(
      cros_network_config_.BindNewPipeAndPassReceiver());
  cros_network_config_->AddObserver(receiver_.BindNewPipeAndPassRemote());

  phone_model_->AddObserver(this);
  multidevice_setup_client_->AddObserver(this);

  // Compute current status.
  status_ = ComputeStatus();

  // Load the current tether network if it exists.
  FetchVisibleTetherNetwork();
}

TetherControllerImpl::~TetherControllerImpl() {
  phone_model_->RemoveObserver(this);
  multidevice_setup_client_->RemoveObserver(this);
}

TetherController::Status TetherControllerImpl::GetStatus() const {
  PA_LOG(VERBOSE) << __func__ << ": status = " << status_;
  return status_;
}

void TetherControllerImpl::ScanForAvailableConnection() {
  if (status_ != Status::kConnectionUnavailable) {
    PA_LOG(WARNING) << "Received request to scan for available connection, but "
                    << "a scan cannot be performed because the current status "
                    << "is " << status_;
    return;
  }

  PA_LOG(INFO) << "Scanning for available connection.";
  cros_network_config_->RequestNetworkScan(NetworkType::kTether);
}

void TetherControllerImpl::AttemptConnection() {
  if (status_ != Status::kConnectionUnavailable &&
      status_ != Status::kConnectionAvailable) {
    PA_LOG(WARNING) << "Received request to attempt a connection, but a "
                    << "connection cannot be attempted because the current "
                    << "status is " << status_;
    return;
  }

  PA_LOG(INFO) << "Attempting connection; current status is " << status_;
  user_action_recorder_->RecordTetherConnectionAttempt();
  util::LogTetherConnectionResult(
      util::TetherConnectionResult::kAttemptConnection);
  is_attempting_connection_ = true;

  FeatureState feature_state =
      multidevice_setup_client_->GetFeatureState(Feature::kInstantTethering);

  if (feature_state == FeatureState::kEnabledByUser) {
    PerformConnectionAttempt();
    return;
  }

  // The Tethering feature was disabled and must be enabled first, before a
  // connection attempt can be made.
  DCHECK(feature_state == FeatureState::kDisabledByUser);
  AttemptTurningOnTethering();
}

void TetherControllerImpl::AttemptTurningOnTethering() {
  SetConnectDisconnectStatus(
      ConnectDisconnectStatus::kTurningOnInstantTethering);
  multidevice_setup_client_->SetFeatureEnabledState(
      Feature::kInstantTethering,
      /*enabled=*/true,
      /*auth_token=*/std::nullopt,
      base::BindOnce(&TetherControllerImpl::OnSetFeatureEnabled,
                     weak_ptr_factory_.GetWeakPtr()));
}

void TetherControllerImpl::OnSetFeatureEnabled(bool success) {
  if (connect_disconnect_status_ !=
      ConnectDisconnectStatus::kTurningOnInstantTethering) {
    return;
  }

  if (success) {
    PerformConnectionAttempt();
    return;
  }

  PA_LOG(WARNING) << "Failed to enable InstantTethering";
  SetConnectDisconnectStatus(ConnectDisconnectStatus::kIdle);
}

void TetherControllerImpl::OnFeatureStatesChanged(
    const MultiDeviceSetupClient::FeatureStatesMap& feature_states_map) {
  FeatureState feature_state =
      multidevice_setup_client_->GetFeatureState(Feature::kInstantTethering);

  // The |connect_disconnect_status_| should always be
  // ConnectDisconnectStatus::kIdle if the |feature_state| is anything other
  // than |FeatureState::kEnabledByUser|. A |feature_status| other than
  // |FeatureState::kEnabledByUser| would indicate that Instant Tethering became
  // disabled or disallowed.
  if (feature_state != FeatureState::kEnabledByUser) {
    SetConnectDisconnectStatus(ConnectDisconnectStatus::kIdle);
  } else if (connect_disconnect_status_ !=
             ConnectDisconnectStatus::kTurningOnInstantTethering) {
    UpdateStatus();
  }
}

void TetherControllerImpl::PerformConnectionAttempt() {
  if (!tether_network_.is_null()) {
    StartConnect();
    return;
  }
  SetConnectDisconnectStatus(
      ConnectDisconnectStatus::kScanningForEligiblePhone);
  cros_network_config_->RequestNetworkScan(NetworkType::kTether);
}

void TetherControllerImpl::StartConnect() {
  DCHECK(!tether_network_.is_null());
  SetConnectDisconnectStatus(
      ConnectDisconnectStatus::kConnectingToEligiblePhone);
  connector_->StartConnect(
      tether_network_->guid,
      base::BindOnce(&TetherControllerImpl::OnStartConnectCompleted,
                     weak_ptr_factory_.GetWeakPtr()));
}

void TetherControllerImpl::OnStartConnectCompleted(StartConnectResult result,
                                                   const std::string& message) {
  if (result != StartConnectResult::kSuccess) {
    PA_LOG(WARNING) << "Start connect failed with result " << result
                    << " and message " << message;
  }

  if (connect_disconnect_status_ !=
      ConnectDisconnectStatus::kConnectingToEligiblePhone) {
    return;
  }

  // Note that OnVisibleTetherNetworkFetched() may not have called
  // SetConnectDisconnectStatus() with kIdle at this point, so this should go
  // ahead and do it.
  SetConnectDisconnectStatus(ConnectDisconnectStatus::kIdle);
}

void TetherControllerImpl::Disconnect() {
  if (status_ != Status::kConnecting && status_ != Status::kConnected) {
    PA_LOG(WARNING) << "Received request to disconnect, but no connection or "
                    << "connection attempt is in progress. Current status is "
                    << status_;
    return;
  }

  // If |status_| is Status::kConnecting, a tether network may not be available
  // yet e.g this class may be in the process of enabling Instant Tethering.
  if (tether_network_.is_null()) {
    SetConnectDisconnectStatus(ConnectDisconnectStatus::kIdle);
    return;
  }

  PA_LOG(INFO) << "Attempting disconnection; current status is " << status_;
  SetConnectDisconnectStatus(ConnectDisconnectStatus::kDisconnecting);
  connector_->StartDisconnect(
      tether_network_->guid,
      base::BindOnce(&TetherControllerImpl::OnDisconnectCompleted,
                     weak_ptr_factory_.GetWeakPtr()));
}

void TetherControllerImpl::OnModelChanged() {
  UpdateStatus();
}

void TetherControllerImpl::OnDisconnectCompleted(bool success) {
  if (connect_disconnect_status_ != ConnectDisconnectStatus::kDisconnecting)
    return;

  SetConnectDisconnectStatus(ConnectDisconnectStatus::kIdle);

  // Fetch the tether network and its updated connection state, if it exists.
  // By the time OnDisconnectCompleted() is called, the connection state is
  // properly updated to ConnectionStateType::kDisconnected, so a fetch may be
  // necessary to promptly update |tether_network_|, as neither
  // OnActiveNetworksChanged() nor OnNetworkStateListChanged() may be called
  // shortly afterwards with the latest network information.
  FetchVisibleTetherNetwork();

  if (!success)
    PA_LOG(WARNING) << "Failed to disconnect tether network";
}

void TetherControllerImpl::OnActiveNetworksChanged(
    std::vector<chromeos::network_config::mojom::NetworkStatePropertiesPtr>
        networks) {
  // Active networks either changed externally (e.g via OS Settings or a new
  // actve network added), or as a result of a call to AttemptConnection() or
  // Disconnect(). This is needed for the case of
  // ConnectionStateType::kConnecting in ComputeStatus().
  //
  // Note: When OnActiveNetworksChanged() is called shortly after starting a
  // disconnect to a ConnectionStateType::kConnecting |tether_network_|, the
  // |tether_network_|'s ConnectionStateType may still remain in the
  // ConnectionStateType::kConnecting state. This may happen if on the phone,
  // hotspot is off but bluetooth tethering is on, and a connection attempt is
  // made, but the user does not acknowledge the notification to connect on
  // their phone, and subsequently decides to disconnect while
  // |tether_network_|'s ConnectionStateType is still
  // ConnectionStateType::kConnecting.
  FetchVisibleTetherNetwork();
}

void TetherControllerImpl::OnNetworkStateListChanged() {
  // Any network change whether caused externally or within this class should
  // be reflected to the state of this class (e.g user makes changes to Tether
  // network in OS Settings).
  FetchVisibleTetherNetwork();
}

void TetherControllerImpl::OnDeviceStateListChanged() {
  if (connect_disconnect_status_ !=
      ConnectDisconnectStatus::kScanningForEligiblePhone) {
    return;
  }

  cros_network_config_->GetDeviceStateList(
      base::BindOnce(&TetherControllerImpl::OnGetDeviceStateList,
                     weak_ptr_factory_.GetWeakPtr()));
}

void TetherControllerImpl::OnGetDeviceStateList(
    std::vector<DeviceStatePropertiesPtr> devices) {
  if (connect_disconnect_status_ !=
      ConnectDisconnectStatus::kScanningForEligiblePhone) {
    return;
  }

  // There should only be one Tether device in the list.
  bool is_tether_device_scanning = false;
  for (const auto& device : devices) {
    NetworkType type = device->type;
    if (type != NetworkType::kTether)
      continue;
    is_tether_device_scanning = device->scanning;
    break;
  }

  if (!is_tether_device_scanning) {
    NotifyAttemptConnectionScanFailed();
    SetConnectDisconnectStatus(ConnectDisconnectStatus::kIdle);
  }
}

void TetherControllerImpl::FetchVisibleTetherNetwork() {
  // Return the connected, connecting, or connectable Tether network.
  connector_->GetNetworkStateList(
      chromeos::network_config::mojom::NetworkFilter::New(FilterType::kVisible,
                                                          NetworkType::kTether,
                                                          /*limit=*/0),
      base::BindOnce(&TetherControllerImpl::OnVisibleTetherNetworkFetched,
                     weak_ptr_factory_.GetWeakPtr()));
}

void TetherControllerImpl::OnVisibleTetherNetworkFetched(
    std::vector<chromeos::network_config::mojom::NetworkStatePropertiesPtr>
        networks) {
  chromeos::network_config::mojom::NetworkStatePropertiesPtr
      previous_tether_network = std::move(tether_network_);

  if (!networks.empty()) {
    // The number of tether networks is expected to be at most 1, though some
    // tests do use multiple networks.
    tether_network_ = std::move(networks[0]);
  } else {
    tether_network_ = nullptr;
  }

  // No observeable changes to the tether network specifically. This fetch
  // was initiated by a change in a non Tether network type.
  if (tether_network_.Equals(previous_tether_network))
    return;

  // If AttemptConnection() was called when Instant Tethering was disabled.
  // The feature must be enabled before scanning can occur.
  if (connect_disconnect_status_ ==
      ConnectDisconnectStatus::kTurningOnInstantTethering) {
    UpdateStatus();
    return;
  }

  // If AttemptConnection() was called when there was no available tether
  // connection.
  if (connect_disconnect_status_ ==
          ConnectDisconnectStatus::kScanningForEligiblePhone &&
      !tether_network_.is_null()) {
    StartConnect();
    return;
  }

  // If there is no attempt connection in progress, or an attempt connection
  // caused OnVisibleTetherNetworkFetched() to be fired. This case also occurs
  // in the event that Tethering settings are changed externally from this class
  // (e.g user connects via Settings).
  SetConnectDisconnectStatus(ConnectDisconnectStatus::kIdle);
}

void TetherControllerImpl::SetConnectDisconnectStatus(
    ConnectDisconnectStatus connect_disconnect_status) {
  if (connect_disconnect_status_ != connect_disconnect_status)
    weak_ptr_factory_.InvalidateWeakPtrs();
  connect_disconnect_status_ = connect_disconnect_status;
  UpdateStatus();
}

void TetherControllerImpl::UpdateStatus() {
  Status status = ComputeStatus();

  if (status_ == status)
    return;

  PA_LOG(INFO) << "TetherController status update: " << status_ << " => "
               << status;

  status_ = status;

  if (is_attempting_connection_ && status_ == Status::kConnected)
    util::LogTetherConnectionResult(util::TetherConnectionResult::kSuccess);

  if (status_ != Status::kConnecting)
    is_attempting_connection_ = false;

  NotifyStatusChanged();
}

TetherController::Status TetherControllerImpl::ComputeStatus() const {
  FeatureState feature_state =
      multidevice_setup_client_->GetFeatureState(Feature::kInstantTethering);

  if (feature_state != FeatureState::kDisabledByUser &&
      feature_state != FeatureState::kEnabledByUser) {
    // Tethering may be for instance, prohibited by policy or not supported
    // by the phone or Chromebook.
    return Status::kIneligibleForFeature;
  }

  if (phone_model_->phone_status_model().has_value()) {
    // If the phone status exists, and it indicates that the phone
    // does not have reception, the status becomes no kNoReception.
    bool does_sim_exist_with_reception =
        phone_model_->phone_status_model()->mobile_status() ==
        PhoneStatusModel::MobileStatus::kSimWithReception;

    if (!does_sim_exist_with_reception)
      return Status::kNoReception;
  }

  if (connect_disconnect_status_ ==
          ConnectDisconnectStatus::kTurningOnInstantTethering ||
      connect_disconnect_status_ ==
          ConnectDisconnectStatus::kScanningForEligiblePhone ||
      connect_disconnect_status_ ==
          ConnectDisconnectStatus::kConnectingToEligiblePhone) {
    return Status::kConnecting;
  }

  if (feature_state == FeatureState::kDisabledByUser)
    return Status::kConnectionUnavailable;

  if (tether_network_.is_null())
    return Status::kConnectionUnavailable;

  ConnectionStateType connection_state = tether_network_->connection_state;

  switch (connection_state) {
    case ConnectionStateType::kOnline:
      [[fallthrough]];
    case ConnectionStateType::kConnected:
      [[fallthrough]];
    case ConnectionStateType::kPortal:
      return Status::kConnected;

    case ConnectionStateType::kConnecting:
      return Status::kConnecting;

    case ConnectionStateType::kNotConnected:
      return Status::kConnectionAvailable;
  }
  return Status::kConnectionUnavailable;
}

}  // namespace ash::phonehub