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

#include "ash/assistant/assistant_controller_impl.h"

#include <algorithm>
#include <utility>

#include "ash/accessibility/accessibility_controller.h"
#include "ash/assistant/util/deep_link_util.h"
#include "ash/capture_mode/capture_mode_controller.h"
#include "ash/constants/ash_features.h"
#include "ash/public/cpp/android_intent_helper.h"
#include "ash/public/cpp/assistant/assistant_state.h"
#include "ash/public/cpp/new_window_delegate.h"
#include "ash/public/cpp/session/session_types.h"
#include "ash/public/mojom/assistant_volume_control.mojom.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "base/functional/bind.h"
#include "base/memory/scoped_refptr.h"
#include "chromeos/ash/services/assistant/public/cpp/assistant_browser_delegate.h"
#include "chromeos/ash/services/assistant/public/cpp/assistant_enums.h"
#include "chromeos/ash/services/assistant/public/cpp/assistant_prefs.h"
#include "chromeos/ash/services/assistant/public/cpp/assistant_service.h"
#include "chromeos/ash/services/assistant/public/cpp/features.h"
#include "chromeos/ash/services/libassistant/public/cpp/assistant_feedback.h"
#include "components/account_id/account_id.h"
#include "components/prefs/pref_registry_simple.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "url/gurl.h"

namespace ash {

namespace {

const AccountId& GetActiveUserAccountId() {
  const UserSession* active_user_session =
      Shell::Get()->session_controller()->GetUserSession(0);
  DCHECK(active_user_session);
  return active_user_session->user_info.account_id;
}

}  // namespace

AssistantControllerImpl::AssistantControllerImpl() {
  Shell::Get()->AddShellObserver(this);
  assistant_state_controller_.AddObserver(this);
  CrasAudioHandler::Get()->AddAudioObserver(this);
  AddObserver(this);

  // The Assistant service needs to have accessibility state synced with ash
  // and be notified of any accessibility status changes in the future to
  // provide an opportunity to turn on/off A11Y features.
  Shell::Get()->accessibility_controller()->AddObserver(this);

  color_mode_observer_.Observe(DarkLightModeControllerImpl::Get());

  NotifyConstructed();
}

AssistantControllerImpl::~AssistantControllerImpl() = default;

// static
void AssistantControllerImpl::RegisterProfilePrefs(
    PrefRegistrySimple* registry) {
  AssistantInteractionControllerImpl::RegisterProfilePrefs(registry);
  AssistantUiControllerImpl::RegisterProfilePrefs(registry);
}

void AssistantControllerImpl::BindReceiver(
    mojo::PendingReceiver<mojom::AssistantVolumeControl> receiver) {
  if (assistant_volume_control_receiver_.is_bound()) {
    assistant_volume_control_receiver_.reset();
  }
  assistant_volume_control_receiver_.Bind(std::move(receiver));
}

void AssistantControllerImpl::SetAssistant(assistant::Assistant* assistant) {
  assistant_ = assistant;

  // Provide reference to sub-controllers.
  assistant_alarm_timer_controller_.SetAssistant(assistant);
  assistant_interaction_controller_.SetAssistant(assistant);
  assistant_notification_controller_.SetAssistant(assistant);
  assistant_ui_controller_.SetAssistant(assistant);

  if (assistant) {
    for (AssistantControllerObserver& observer : observers_)
      observer.OnAssistantReady();
  }
}

void AssistantControllerImpl::SendAssistantFeedback(
    bool assistant_debug_info_allowed,
    const std::string& feedback_description,
    const std::string& screenshot_png) {
  if (!IsAssistantReady()) {
    return;
  }

  assistant::AssistantFeedback assistant_feedback;
  assistant_feedback.assistant_debug_info_allowed =
      assistant_debug_info_allowed;
  assistant_feedback.description = feedback_description;
  assistant_feedback.screenshot_png =
      std::vector<uint8_t>(screenshot_png.begin(), screenshot_png.end());
  assistant_->SendAssistantFeedback(std::move(assistant_feedback));
}

void AssistantControllerImpl::StartSpeakerIdEnrollmentFlow() {
  setup_controller()->StartOnboarding(false /* relaunch */,
                                      FlowType::kSpeakerIdEnrollment);
}

void AssistantControllerImpl::DownloadImage(
    const GURL& url,
    ImageDownloader::DownloadCallback callback) {
  constexpr net::NetworkTrafficAnnotationTag kNetworkTrafficAnnotationTag =
      net::DefineNetworkTrafficAnnotation("image_downloader", R"(
            semantics {
              sender: "Google Assistant"
              description:
                "The Google Assistant requires dynamic loading of images to "
                "provide a media rich user experience. Images are downloaded "
                "on an as needed basis."
              trigger:
                "Generally triggered in direct response to a user issued "
                "query. A single query may necessitate the downloading of "
                "multiple images."
              data: "None."
              destination: GOOGLE_OWNED_SERVICE
            }
            policy {
              cookies_allowed: NO
              setting:
                "The Google Assistant can be enabled/disabled in Chrome "
                "Settings and is subject to eligibility requirements."
              policy_exception_justification:
                "The users can disable this feature. This does not send/store "
                "user data."
            })");

  ImageDownloader::Get()->Download(url, kNetworkTrafficAnnotationTag,
                                   GetActiveUserAccountId(),
                                   std::move(callback));
}

void AssistantControllerImpl::AddObserver(
    AssistantControllerObserver* observer) {
  observers_.AddObserver(observer);
}

void AssistantControllerImpl::RemoveObserver(
    AssistantControllerObserver* observer) {
  observers_.RemoveObserver(observer);
}

void AssistantControllerImpl::OpenUrl(const GURL& url,
                                      bool in_background,
                                      bool from_server) {
  // app_list search result will be opened by `OpenUrl()`. However, the
  // `assistant_` may not be ready. Show a toast to indicate it.
  if (!IsAssistantReady()) {
    assistant_ui_controller_.ShowUnboundErrorToast();
    return;
  }

  if (assistant::util::IsDeepLinkUrl(url)) {
    NotifyDeepLinkReceived(url);
    return;
  }

  auto* android_helper = AndroidIntentHelper::GetInstance();
  if (IsAndroidIntent(url) && !android_helper) {
    NOTREACHED();
  }

  // Give observers an opportunity to perform any necessary handling before we
  // open the specified |url| in a new browser tab.
  NotifyOpeningUrl(url, in_background, from_server);

  if (IsAndroidIntent(url)) {
    android_helper->LaunchAndroidIntent(url.spec());
  } else {
    assistant::AssistantBrowserDelegate::Get()->OpenUrl(url);
  }
  NotifyUrlOpened(url, from_server);
}

void AssistantControllerImpl::OpenAssistantSettings() {
  // Launch Assistant settings via deeplink.
  OpenUrl(assistant::util::CreateAssistantSettingsDeepLink(),
          /*in_background=*/false, /*from_server=*/false);
}

base::WeakPtr<ash::AssistantController> AssistantControllerImpl::GetWeakPtr() {
  return weak_factory_.GetWeakPtr();
}

void AssistantControllerImpl::OnDeepLinkReceived(
    assistant::util::DeepLinkType type,
    const std::map<std::string, std::string>& params) {
  using assistant::util::DeepLinkParam;
  using assistant::util::DeepLinkType;

  switch (type) {
    case DeepLinkType::kChromeSettings: {
      // Chrome Settings deep links are opened in a new browser tab.
      OpenUrl(
          assistant::util::GetChromeSettingsUrl(
              assistant::util::GetDeepLinkParam(params, DeepLinkParam::kPage)),
          /*in_background=*/false, /*from_server=*/false);
      break;
    }
    case DeepLinkType::kFeedback:
      NewWindowDelegate::GetInstance()->OpenFeedbackPage(
          NewWindowDelegate::FeedbackSource::kFeedbackSourceAssistant);

      // Close the assistant UI so that the feedback page is visible.
      assistant_ui_controller_.CloseUi(
          assistant::AssistantExitPoint::kUnspecified);
      break;
    case DeepLinkType::kScreenshot:
      // We close the UI before taking the screenshot as it's probably not the
      // user's intention to include the Assistant in the picture.
      assistant_ui_controller_.CloseUi(
          assistant::AssistantExitPoint::kScreenshot);
      CaptureModeController::Get()->CaptureScreenshotsOfAllDisplays();
      break;
    case DeepLinkType::kTaskManager:
      // Open task manager window.
      NewWindowDelegate::GetInstance()->ShowTaskManager();
      break;
    case DeepLinkType::kUnsupported:
    case DeepLinkType::kAlarmTimer:
    case DeepLinkType::kLists:
    case DeepLinkType::kNotes:
    case DeepLinkType::kOnboarding:
    case DeepLinkType::kQuery:
    case DeepLinkType::kReminders:
    case DeepLinkType::kSettings:
      // No action needed.
      break;
  }
}

void AssistantControllerImpl::SetVolume(int volume, bool user_initiated) {
  volume = std::min(100, volume);
  volume = std::max(volume, 0);
  CrasAudioHandler::Get()->SetOutputVolumePercent(volume);
}

void AssistantControllerImpl::SetMuted(bool muted) {
  CrasAudioHandler::Get()->SetOutputMute(muted);
}

void AssistantControllerImpl::AddVolumeObserver(
    mojo::PendingRemote<mojom::VolumeObserver> observer) {
  volume_observers_.Add(std::move(observer));

  int output_volume = CrasAudioHandler::Get()->GetOutputVolumePercent();
  bool mute = CrasAudioHandler::Get()->IsOutputMuted();
  OnOutputMuteChanged(mute);
  OnOutputNodeVolumeChanged(0 /* node */, output_volume);
}

void AssistantControllerImpl::OnOutputMuteChanged(bool mute_on) {
  for (auto& observer : volume_observers_)
    observer->OnMuteStateChanged(mute_on);
}

void AssistantControllerImpl::OnOutputNodeVolumeChanged(uint64_t node,
                                                        int volume) {
  // |node| refers to the active volume device, which we don't care here.
  for (auto& observer : volume_observers_)
    observer->OnVolumeChanged(volume);
}

void AssistantControllerImpl::OnAccessibilityStatusChanged() {
  if (!IsAssistantReady()) {
    return;
  }

  // The Assistant service needs to be informed of changes to accessibility
  // state so that it can turn on/off A11Y features appropriately.
  assistant_->OnAccessibilityStatusChanged(
      Shell::Get()->accessibility_controller()->spoken_feedback().enabled());
}

void AssistantControllerImpl::OnColorModeChanged(bool dark_mode_enabled) {
  if (!IsAssistantReady()) {
    return;
  }

  assistant_->OnColorModeChanged(dark_mode_enabled);
}

void AssistantControllerImpl::OnShellDestroying() {
  NotifyDestroying();
  CrasAudioHandler::Get()->RemoveAudioObserver(this);
  Shell::Get()->accessibility_controller()->RemoveObserver(this);
  assistant_state_controller_.RemoveObserver(this);
  Shell::Get()->RemoveShellObserver(this);
  RemoveObserver(this);
}

bool AssistantControllerImpl::IsAssistantReady() const {
  if (!assistant_) {
    return false;
  }

  if (AssistantState::Get()->assistant_status() ==
      assistant::AssistantStatus::NOT_READY) {
    return false;
  }

  return true;
}

void AssistantControllerImpl::NotifyConstructed() {
  for (AssistantControllerObserver& observer : observers_)
    observer.OnAssistantControllerConstructed();
}

void AssistantControllerImpl::NotifyDestroying() {
  for (AssistantControllerObserver& observer : observers_)
    observer.OnAssistantControllerDestroying();
}

void AssistantControllerImpl::NotifyDeepLinkReceived(const GURL& deep_link) {
  using assistant::util::DeepLinkType;

  // Retrieve deep link type and parsed parameters.
  DeepLinkType type = assistant::util::GetDeepLinkType(deep_link);
  const std::map<std::string, std::string> params =
      assistant::util::GetDeepLinkParams(deep_link);

  for (AssistantControllerObserver& observer : observers_)
    observer.OnDeepLinkReceived(type, params);
}

void AssistantControllerImpl::NotifyOpeningUrl(const GURL& url,
                                               bool in_background,
                                               bool from_server) {
  for (AssistantControllerObserver& observer : observers_)
    observer.OnOpeningUrl(url, in_background, from_server);
}

void AssistantControllerImpl::NotifyUrlOpened(const GURL& url,
                                              bool from_server) {
  for (AssistantControllerObserver& observer : observers_)
    observer.OnUrlOpened(url, from_server);
}

void AssistantControllerImpl::OnAssistantStatusChanged(
    assistant::AssistantStatus status) {
  switch (status) {
    case assistant::AssistantStatus::NOT_READY:
      assistant_volume_control_receiver_.reset();
      assistant_ui_controller_.CloseUi(
          assistant::AssistantExitPoint::kUnspecified);
      break;
    case assistant::AssistantStatus::READY:
      OnAccessibilityStatusChanged();
      OnColorModeChanged(
          DarkLightModeControllerImpl::Get()->IsDarkModeEnabled());
      break;
  }
}

void AssistantControllerImpl::OnLockedFullScreenStateChanged(bool enabled) {
  if (enabled)
    assistant_ui_controller_.CloseUi(
        assistant::AssistantExitPoint::kUnspecified);
}

void AssistantControllerImpl::BindVolumeControl(
    mojo::PendingReceiver<mojom::AssistantVolumeControl> receiver) {
  Shell::Get()->assistant_controller()->BindReceiver(std::move(receiver));
}

}  // namespace ash