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

#include "chrome/browser/ash/video_conference/video_conference_app_service_client.h"

#include <variant>

#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "base/containers/contains.h"
#include "base/functional/callback_helpers.h"
#include "base/strings/utf_string_conversions.h"
#include "base/unguessable_token.h"
#include "chrome/browser/apps/app_service/app_service_proxy_ash.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/apps/app_service/metrics/app_platform_metrics.h"
#include "chrome/browser/ash/crosapi/crosapi_ash.h"
#include "chrome/browser/ash/crosapi/crosapi_manager.h"
#include "chrome/browser/ash/video_conference/video_conference_manager_ash.h"
#include "chrome/browser/chromeos/video_conference/video_conference_ukm_helper.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "components/services/app_service/public/cpp/app_capability_access_cache_wrapper.h"
#include "components/services/app_service/public/cpp/app_registry_cache.h"
#include "components/services/app_service/public/cpp/app_types.h"
#include "components/user_manager/user_manager.h"
#include "services/metrics/public/cpp/ukm_recorder.h"

namespace ash {
namespace {
using video_conference::VideoConferenceUkmHelper;

VideoConferenceAppServiceClient* g_client_instance = nullptr;

crosapi::mojom::VideoConferenceAppType ToVideoConferenceAppType(
    apps::AppType app_type) {
  switch (app_type) {
    case apps::AppType::kArc:
      return crosapi::mojom::VideoConferenceAppType::kArcApp;
    case apps::AppType::kChromeApp:
      return crosapi::mojom::VideoConferenceAppType::kChromeApp;
    case apps::AppType::kWeb:
      return crosapi::mojom::VideoConferenceAppType::kWebApp;
    case apps::AppType::kExtension:
      return crosapi::mojom::VideoConferenceAppType::kChromeExtension;
    default:
      return crosapi::mojom::VideoConferenceAppType::kAppServiceUnknown;
  }
}

bool IsPermissionAsked(const apps::PermissionPtr& permission) {
  return std::holds_alternative<apps::TriState>(permission->value) &&
         std::get<apps::TriState>(permission->value) == apps::TriState::kAsk;
}

}  // namespace

VideoConferenceAppServiceClient::VideoConferenceAppServiceClient()
    : client_id_(base::UnguessableToken::Create()),
      status_(crosapi::mojom::VideoConferenceMediaUsageStatus::New(
          /*client_id=*/client_id_,
          /*has_media_app=*/false,
          /*has_camera_permission=*/false,
          /*has_microphone_permission=*/false,
          /*is_capturing_camera=*/false,
          /*is_capturing_microphone=*/false,
          /*is_capturing_screen=*/false)) {
  crosapi::CrosapiManager::Get()
      ->crosapi_ash()
      ->video_conference_manager_ash()
      ->RegisterCppClient(this, client_id_);

  session_observation_.Observe(Shell::Get()->session_controller());

  // Initialize with current session state.
  OnSessionStateChanged(Shell::Get()->session_controller()->GetSessionState());

  g_client_instance = this;
}

VideoConferenceAppServiceClient::~VideoConferenceAppServiceClient() {
  // C++ clients are responsible for manually calling |UnregisterClient| on the
  // manager when disconnecting.
  crosapi::CrosapiManager::Get()
      ->crosapi_ash()
      ->video_conference_manager_ash()
      ->UnregisterClient(client_id_);

  g_client_instance = nullptr;
}

void VideoConferenceAppServiceClient::GetMediaApps(
    GetMediaAppsCallback callback) {
  std::vector<crosapi::mojom::VideoConferenceMediaAppInfoPtr> apps;

  for (const auto& [app_id, app_state] : id_to_app_state_) {
    const std::string app_name = GetAppName(app_id);
    // app_name should not be empty.
    if (app_name.empty()) {
      continue;
    }

    apps.push_back(crosapi::mojom::VideoConferenceMediaAppInfo::New(
        /*id=*/app_state.token,
        /*last_activity_time=*/app_state.last_activity_time,
        /*is_capturing_camera=*/app_state.is_capturing_camera,
        /*is_capturing_microphone=*/app_state.is_capturing_microphone,
        /*is_capturing_screen=*/false,
        /*title=*/base::UTF8ToUTF16(app_name),
        /*url=*/std::nullopt,
        /*app_type=*/ToVideoConferenceAppType(GetAppType(app_id))));
  }

  std::move(callback).Run(std::move(apps));
}

void VideoConferenceAppServiceClient::ReturnToApp(
    const base::UnguessableToken& token,
    ReturnToAppCallback callback) {
  // Go through `id_to_app_state_` to find possible app to reactivate.
  // This loop is inevitable unless we use multiple maps which also makes things
  // complicated.
  AppIdString app_id;
  for (const auto& [id, app_state] : id_to_app_state_) {
    if (app_state.token == token) {
      app_id = id;
      break;
    }
  }

  if (app_id.empty()) {
    // This will happen very frequently; this is not an error, but expected
    // behavior. This indicates that the app represented by this id does not
    // belong to this client.
    std::move(callback).Run(false);
    return;
  }

  for (const apps::Instance* instance :
       instance_registry_->GetInstances(app_id)) {
    // This is required in unit tests to reactivate an app.
    instance->Window()->Show();
    // This is required in virtual desktop to reactivate an arc++ app.
    instance->Window()->Focus();
  }
  std::move(callback).Run(true);
}

void VideoConferenceAppServiceClient::SetSystemMediaDeviceStatus(
    crosapi::mojom::VideoConferenceMediaDevice device,
    bool disabled,
    SetSystemMediaDeviceStatusCallback callback) {
  switch (device) {
    case crosapi::mojom::VideoConferenceMediaDevice::kCamera:
      camera_system_disabled_ = disabled;
      std::move(callback).Run(true);
      return;
    case crosapi::mojom::VideoConferenceMediaDevice::kMicrophone:
      microphone_system_disabled_ = disabled;
      std::move(callback).Run(true);
      return;
    case crosapi::mojom::VideoConferenceMediaDevice::kUnusedDefault:
      std::move(callback).Run(false);
      return;
  }
}

void VideoConferenceAppServiceClient::StopAllScreenShare() {}

void VideoConferenceAppServiceClient::OnCapabilityAccessUpdate(
    const apps::CapabilityAccessUpdate& update) {
  const AppIdString& app_id = update.AppId();
  // Only track Arc++ apps for now. All other apps are tracked by
  // VideoConferenceManagerClientImpl. We should only expand to more types after
  // confirming its compatibility with VideoConferenceManagerClientImpl.
  if (GetAppType(app_id) != apps::AppType::kArc) {
    return;
  }

  // For now, we only care about camera/microphone accessing.
  if (!update.CameraChanged() && !update.MicrophoneChanged()) {
    return;
  }

  const bool is_capturing_camera = update.Camera().value_or(false);
  const bool is_capturing_microphone = update.Microphone().value_or(false);
  const bool is_already_tracked = base::Contains(id_to_app_state_, app_id);

  // We only want to start tracking a app if it starts to accessing
  // microphone/camera.
  if (!is_capturing_camera && !is_capturing_microphone && !is_already_tracked) {
    return;
  }

  if (!is_already_tracked && ::video_conference::ShouldSkipId(app_id)) {
    return;
  }

  AppState& state = GetOrAddAppState(app_id);
  const std::string app_name = GetAppName(app_id);

  auto& ukm_hepler = id_to_ukm_hepler_[app_id];

  if (update.CameraChanged()) {
    state.is_capturing_camera = is_capturing_camera;
    if (ukm_hepler) {
      ukm_hepler->RegisterCapturingUpdate(
          video_conference::VideoConferenceMediaType::kCamera,
          is_capturing_camera);
    }
  }

  if (update.MicrophoneChanged()) {
    state.is_capturing_microphone = is_capturing_microphone;
    if (ukm_hepler) {
      ukm_hepler->RegisterCapturingUpdate(
          video_conference::VideoConferenceMediaType::kMicrophone,
          is_capturing_microphone);
    }
  }

  // For some apps, the instance is firstly removed, and then
  // OnCapabilityAccessUpdate is called. There is a chance that the app_id is
  // removed after OnInstanceUpdate, but added back in OnCapabilityAccessUpdate.
  // Thus we want to remove the app_id if it is not capturing and no instance
  // running.
  if (!state.is_capturing_microphone && !state.is_capturing_camera) {
    MaybeRemoveApp(app_id);
  }

  HandleMediaUsageUpdate();

  // This will be an AnchoredNudge, which is only visible if the tray is
  // visible; so we have to call this after HandleMediaUsageUpdate.
  if (update.CameraChanged() && is_capturing_camera &&
      camera_system_disabled_) {
    crosapi::CrosapiManager::Get()
        ->crosapi_ash()
        ->video_conference_manager_ash()
        ->NotifyDeviceUsedWhileDisabled(
            crosapi::mojom::VideoConferenceMediaDevice::kCamera,
            base::UTF8ToUTF16(app_name), base::DoNothingAs<void(bool)>());
  }

  if (update.MicrophoneChanged() && is_capturing_microphone &&
      microphone_system_disabled_) {
    crosapi::CrosapiManager::Get()
        ->crosapi_ash()
        ->video_conference_manager_ash()
        ->NotifyDeviceUsedWhileDisabled(
            crosapi::mojom::VideoConferenceMediaDevice::kMicrophone,
            base::UTF8ToUTF16(app_name), base::DoNothingAs<void(bool)>());
  }
}

void VideoConferenceAppServiceClient::OnAppCapabilityAccessCacheWillBeDestroyed(
    apps::AppCapabilityAccessCache* cache) {
  app_capability_observation_.Reset();
  capability_cache_ = nullptr;
}

void VideoConferenceAppServiceClient::OnInstanceUpdate(
    const apps::InstanceUpdate& update) {
  const AppIdString& app_id = update.AppId();

  // We only care about the apps being tracked already.
  if (!base::Contains(id_to_app_state_, app_id)) {
    return;
  }

  // An instance of app_id is about to be destructed.
  if (update.IsDestruction() &&
      instance_registry_->GetInstances(app_id).size() <= 1) {
    // The last instance maybe removed after the OnInstanceUpdate, so we post a
    // task to also remove the app_id if the instance is indeed removed.
    base::SequencedTaskRunner::GetCurrentDefault()->PostNonNestableTask(
        FROM_HERE,
        base::BindOnce(&VideoConferenceAppServiceClient::MaybeRemoveApp,
                       weak_ptr_factory_.GetWeakPtr(), app_id));
    return;
  }

  if (update.StateChanged() &&
      (update.State() & apps::InstanceState::kActive) != 0) {
    id_to_app_state_[app_id].last_activity_time = update.LastUpdatedTime();
    return;
  }
}

void VideoConferenceAppServiceClient::OnInstanceRegistryWillBeDestroyed(
    apps::InstanceRegistry* cache) {
  instance_registry_observation_.Reset();
  instance_registry_ = nullptr;
}

void VideoConferenceAppServiceClient::OnSessionStateChanged(
    session_manager::SessionState state) {
  if (state != session_manager::SessionState::ACTIVE) {
    return;
  }

  Profile* profile = ProfileManager::GetActiveUserProfile();
  user_manager::User* active_user =
      user_manager::UserManager::Get()->GetActiveUser();

  // Skip the profile that AppServiceProxy is not available.
  if (!apps::AppServiceProxyFactory::IsAppServiceAvailableForProfile(profile) ||
      !active_user) {
    instance_registry_observation_.Reset();
    app_capability_observation_.Reset();
    return;
  }

  auto* ash_proxy = apps::AppServiceProxyFactory::GetForProfile(profile);
  instance_registry_ = &ash_proxy->InstanceRegistry();
  app_registry_ = &ash_proxy->AppRegistryCache();

  instance_registry_observation_.Reset();
  instance_registry_observation_.Observe(instance_registry_);

  capability_cache_ =
      apps::AppCapabilityAccessCacheWrapper::Get().GetAppCapabilityAccessCache(
          active_user->GetAccountId());
  app_capability_observation_.Reset();
  app_capability_observation_.Observe(capability_cache_);
}

VideoConferenceAppServiceClient*
VideoConferenceAppServiceClient::GetForTesting() {
  return g_client_instance;
}

std::string VideoConferenceAppServiceClient::GetAppName(
    const AppIdString& app_id) {
  std::string app_name;
  app_registry_->ForOneApp(app_id, [&app_name](const apps::AppUpdate& update) {
    app_name = update.Name();
  });
  return app_name;
}

// Get current camera/microphone permission of the `app_id`.
VideoConferenceAppServiceClient::VideoConferencePermissions
VideoConferenceAppServiceClient::GetAppPermission(const AppIdString& app_id) {
  VideoConferencePermissions permissions;

  const bool is_arc_app = GetAppType(app_id) == apps::AppType::kArc;

  app_registry_->ForOneApp(app_id, [&permissions,
                                    is_arc_app](const apps::AppUpdate& update) {
    for (const auto& permission : update.Permissions()) {
      // For Arc++ Apps, kAsk means "Only for this time".
      const bool is_temporarily_enabled =
          is_arc_app && IsPermissionAsked(permission);

      const bool is_currently_enabled =
          permission->IsPermissionEnabled() || is_temporarily_enabled;

      if (permission->permission_type == apps::PermissionType::kCamera) {
        permissions.has_camera_permission = is_currently_enabled;
      }
      if (permission->permission_type == apps::PermissionType::kMicrophone) {
        permissions.has_microphone_permission = is_currently_enabled;
      }
    }
  });
  return permissions;
}

apps::AppType VideoConferenceAppServiceClient::GetAppType(
    const AppIdString& app_id) {
  apps::AppType type = apps::AppType::kUnknown;
  app_registry_->ForOneApp(app_id, [&type](const apps::AppUpdate& update) {
    type = update.AppType();
  });
  return type;
}

VideoConferenceAppServiceClient::AppState&
VideoConferenceAppServiceClient::GetOrAddAppState(const std::string& app_id) {
  if (!base::Contains(id_to_app_state_, app_id)) {
    id_to_app_state_[app_id] = AppState{base::UnguessableToken::Create(),
                                        base::Time::Now(), false, false};

    if (test_ukm_recorder_) {
      // In testing environment, using TestUkmRecorder and test SourceID.
      id_to_ukm_hepler_[app_id] = std::make_unique<VideoConferenceUkmHelper>(
          test_ukm_recorder_, test_ukm_recorder_->GetNewSourceID());
    } else {
      // In real environment, using real UkmRecorder and real SourceID.
      const auto source_id = apps::AppPlatformMetrics::GetSourceId(
          ProfileManager::GetActiveUserProfile(), app_id);
      if (source_id != ukm::kInvalidSourceId) {
        id_to_ukm_hepler_[app_id] = std::make_unique<VideoConferenceUkmHelper>(
            ukm::UkmRecorder::Get(), source_id);
      }
    }
  }
  return id_to_app_state_[app_id];
}

void VideoConferenceAppServiceClient::MaybeRemoveApp(
    const AppIdString& app_id) {
  // The app_id should also be removed if:
  // (1) all running instances of app_id are destructed.
  // (2) in an extreme case, the instance_registry_ is reset.
  if (!instance_registry_ || !instance_registry_->ContainsAppId(app_id)) {
    id_to_app_state_.erase(app_id);
    id_to_ukm_hepler_.erase(app_id);
    HandleMediaUsageUpdate();
  }
}

void VideoConferenceAppServiceClient::HandleMediaUsageUpdate() {
  crosapi::mojom::VideoConferenceMediaUsageStatusPtr new_status =
      crosapi::mojom::VideoConferenceMediaUsageStatus::New();
  new_status->client_id = client_id_;
  new_status->has_media_app = !id_to_app_state_.empty();

  for (const auto& [app_id, app_state] : id_to_app_state_) {
    new_status->is_capturing_camera |= app_state.is_capturing_camera;
    new_status->is_capturing_microphone |= app_state.is_capturing_microphone;

    VideoConferencePermissions permissions = GetAppPermission(app_id);
    new_status->has_camera_permission |= permissions.has_camera_permission;
    new_status->has_microphone_permission |=
        permissions.has_microphone_permission;
  }

  // If `status` equals the previously sent status, don't notify manager.
  if (new_status.Equals(status_)) {
    return;
  }
  status_ = new_status->Clone();

  auto callback = base::BindOnce([](bool success) {
    if (!success) {
      LOG(ERROR)
          << "VideoConferenceManager::NotifyMediaUsageUpdate did not succeed.";
    }
  });
  crosapi::CrosapiManager::Get()
      ->crosapi_ash()
      ->video_conference_manager_ash()
      ->NotifyMediaUsageUpdate(std::move(new_status), std::move(callback));
}

}  // namespace ash