// 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 "chrome/browser/sharesheet/sharesheet_service.h"

#include <algorithm>
#include <optional>
#include <utility>

#include "base/functional/bind.h"
#include "base/no_destructor.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "chrome/browser/apps/app_service/app_service_proxy.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/apps/app_service/launch_utils.h"
#include "chrome/browser/sharesheet/share_action/share_action.h"
#include "chrome/browser/sharesheet/share_action/share_action_cache.h"
#include "chrome/browser/sharesheet/sharesheet_controller.h"
#include "chrome/browser/sharesheet/sharesheet_service_delegator.h"
#include "chrome/browser/sharesheet/sharesheet_types.h"
#include "chrome/grit/generated_resources.h"
#include "components/drive/drive_api_util.h"
#include "components/services/app_service/public/cpp/app_launch_util.h"
#include "components/services/app_service/public/cpp/app_types.h"
#include "components/services/app_service/public/cpp/icon_effects.h"
#include "components/services/app_service/public/cpp/intent.h"
#include "content/public/browser/web_contents.h"
#include "ui/display/types/display_constants.h"
#include "ui/views/view.h"

namespace sharesheet {

namespace {

std::u16string& GetSelectedApp() {
  static base::NoDestructor<std::u16string> selected_app;

  return *selected_app;
}

gfx::NativeWindow GetNativeWindowFromWebContents(
    base::WeakPtr<content::WebContents> web_contents) {
  if (!web_contents) {
    return nullptr;
  }

  return web_contents->GetTopLevelNativeWindow();
}

bool HasHostedDocument(const apps::Intent& intent) {
  return std::ranges::any_of(
      intent.files, [](const apps::IntentFilePtr& file) {
        return drive::util::HasHostedDocumentExtension(
            base::FilePath(file->url.ExtractFileName()));
      });
}

}  // namespace

SharesheetService::SharesheetService(Profile* profile)
    : profile_(profile),
      share_action_cache_(std::make_unique<ShareActionCache>(profile_)),
      app_service_proxy_(
          apps::AppServiceProxyFactory::GetForProfile(profile_)) {}

SharesheetService::~SharesheetService() = default;

void SharesheetService::ShowBubble(content::WebContents* web_contents,
                                   apps::IntentPtr intent,
                                   LaunchSource source,
                                   DeliveredCallback delivered_callback,
                                   CloseCallback close_callback) {
  ShowBubble(std::move(intent), source,
             base::BindOnce(&GetNativeWindowFromWebContents,
                            web_contents->GetWeakPtr()),
             std::move(delivered_callback), std::move(close_callback));
}

void SharesheetService::ShowBubble(
    apps::IntentPtr intent,
    LaunchSource source,
    GetNativeWindowCallback get_native_window_callback,
    DeliveredCallback delivered_callback,
    CloseCallback close_callback) {
  DCHECK(intent);
  DCHECK(intent->IsShareIntent());
  CHECK(delivered_callback);

  SharesheetMetrics::RecordSharesheetLaunchSource(source);
  PrepareToShowBubble(std::move(intent), std::move(get_native_window_callback),
                      std::move(delivered_callback), std::move(close_callback));
}

SharesheetController* SharesheetService::GetSharesheetController(
    gfx::NativeWindow native_window) {
  SharesheetServiceDelegator* delegator = GetDelegator(native_window);
  if (!delegator)
    return nullptr;
  return delegator->GetSharesheetController();
}

#if BUILDFLAG(IS_CHROMEOS)
void SharesheetService::ShowNearbyShareBubbleForArc(
    gfx::NativeWindow native_window,
    apps::IntentPtr intent,
    LaunchSource source,
    DeliveredCallback delivered_callback,
    CloseCallback close_callback,
    ActionCleanupCallback cleanup_callback) {
  DCHECK(intent);
  DCHECK(intent->IsShareIntent());

  ShareAction* share_action =
      share_action_cache_->GetActionFromType(ShareActionType::kNearbyShare);
  if (!share_action || !share_action->ShouldShowAction(
                           intent, false /*contains_google_document=*/)) {
    std::move(delivered_callback).Run(SharesheetResult::kCancel);
    return;
  }
  share_action->SetActionCleanupCallbackForArc(std::move(cleanup_callback));
  SharesheetMetrics::RecordSharesheetLaunchSource(source);

  if (!native_window) {
    std::move(delivered_callback).Run(SharesheetResult::kErrorWindowClosed);
    return;
  }
  auto* sharesheet_service_delegator = GetOrCreateDelegator(native_window);
  sharesheet_service_delegator->ShowNearbyShareBubbleForArc(
      std::move(intent), std::move(delivered_callback),
      std::move(close_callback));
}
#endif  // BUILDFLAG(IS_CHROMEOS)

// Cleanup delegator when bubble closes.
void SharesheetService::OnBubbleClosed(
    gfx::NativeWindow native_window,
    const std::optional<ShareActionType>& share_action_type) {
  auto iter = active_delegators_.begin();
  while (iter != active_delegators_.end()) {
    if ((*iter)->GetNativeWindow() == native_window) {
      if (share_action_type) {
        ShareAction* share_action =
            share_action_cache_->GetActionFromType(share_action_type.value());
        if (share_action != nullptr)
          share_action->OnClosing(iter->get()->GetSharesheetController());
      }
      active_delegators_.erase(iter);
      break;
    }
    ++iter;
  }
}

void SharesheetService::OnTargetSelected(
    gfx::NativeWindow native_window,
    const TargetType type,
    const std::optional<ShareActionType>& share_action_type,
    const std::optional<std::u16string>& app_name,
    apps::IntentPtr intent,
    views::View* share_action_view) {
  SharesheetServiceDelegator* delegator = GetDelegator(native_window);
  if (!delegator)
    return;

  RecordUserActionMetrics(share_action_type, app_name);
  if (type == TargetType::kAction) {
    CHECK(share_action_type.has_value());
    ShareAction* share_action =
        share_action_cache_->GetActionFromType(share_action_type.value());
    if (share_action == nullptr)
      return;
    bool has_action_view = share_action->HasActionView();
    delegator->OnActionLaunched(has_action_view);
    share_action->LaunchAction(delegator->GetSharesheetController(),
                               (has_action_view ? share_action_view : nullptr),
                               std::move(intent));
  } else if (type == TargetType::kArcApp || type == TargetType::kWebApp) {
    CHECK(intent);
    CHECK(app_name.has_value());
    LaunchApp(app_name.value(), std::move(intent));
    delegator->CloseBubble(SharesheetResult::kSuccess);
  }
}

bool SharesheetService::OnAcceleratorPressed(
    const ui::Accelerator& accelerator,
    const ShareActionType share_action_type) {
  ShareAction* share_action =
      share_action_cache_->GetActionFromType(share_action_type);
  DCHECK(share_action);
  return share_action == nullptr
             ? false
             : share_action->OnAcceleratorPressed(accelerator);
}

bool SharesheetService::HasShareTargets(const apps::IntentPtr& intent) {
  bool contains_hosted_document = HasHostedDocument(*intent);
  std::vector<apps::IntentLaunchInfo> intent_launch_info =
      app_service_proxy_->GetAppsForIntent(intent);

  return share_action_cache_->HasVisibleActions(intent,
                                                contains_hosted_document) ||
         (!contains_hosted_document && !intent_launch_info.empty());
}

Profile* SharesheetService::GetProfile() {
  return profile_;
}

const gfx::VectorIcon* SharesheetService::GetVectorIcon(
    const std::optional<ShareActionType>& share_action_type) {
  if (!share_action_type.has_value()) {
    return nullptr;
  }
  return share_action_cache_->GetVectorIconFromType(share_action_type.value());
}

void SharesheetService::ShowBubbleForTesting(
    gfx::NativeWindow native_window,
    apps::IntentPtr intent,
    LaunchSource source,
    DeliveredCallback delivered_callback,
    CloseCallback close_callback,
    int num_actions_to_add) {
  CHECK(views::Widget::GetWidgetForNativeWindow(native_window));
  SharesheetMetrics::RecordSharesheetLaunchSource(source);
  for (int i = 0; i < num_actions_to_add; ++i) {
    share_action_cache_->AddShareActionForTesting();  // IN-TEST
  }
  auto targets = GetActionsForIntent(intent);
  OnReadyToShowBubble(native_window, std::move(intent),
                      std::move(delivered_callback), std::move(close_callback),
                      std::move(targets));
}

SharesheetUiDelegate* SharesheetService::GetUiDelegateForTesting(
    gfx::NativeWindow native_window) {
  auto* delegator = GetDelegator(native_window);
  return delegator->GetUiDelegateForTesting();  // IN-TEST
}

// static
void SharesheetService::SetSelectedAppForTesting(
    const std::u16string& target_name) {
  GetSelectedApp() = target_name;
}

void SharesheetService::PrepareToShowBubble(
    apps::IntentPtr intent,
    GetNativeWindowCallback get_native_window_callback,
    DeliveredCallback delivered_callback,
    CloseCallback close_callback) {
  bool contains_hosted_document = HasHostedDocument(*intent);
  auto targets = GetActionsForIntent(intent);

  std::vector<apps::IntentLaunchInfo> intent_launch_info =
      contains_hosted_document ? std::vector<apps::IntentLaunchInfo>()
                               : app_service_proxy_->GetAppsForIntent(intent);
  SharesheetMetrics::RecordSharesheetAppCount(intent_launch_info.size());
  LoadAppIcons(
      std::move(intent_launch_info), std::move(targets), 0,
      base::BindOnce(&SharesheetService::OnAppIconsLoaded,
                     weak_factory_.GetWeakPtr(), std::move(intent),
                     std::move(get_native_window_callback),
                     std::move(delivered_callback), std::move(close_callback)));
}

std::vector<TargetInfo> SharesheetService::GetActionsForIntent(
    const apps::IntentPtr& intent) {
  bool contains_hosted_document = HasHostedDocument(*intent);
  std::vector<TargetInfo> targets;
  auto& actions = share_action_cache_->GetShareActions();
  auto iter = actions.begin();
  while (iter != actions.end()) {
    if ((*iter)->ShouldShowAction(intent, contains_hosted_document)) {
      targets.emplace_back(/*type=*/TargetType::kAction, /*icon=*/std::nullopt,
                           /*launch_name=*/(*iter)->GetActionName(),
                           /*display_name=*/(*iter)->GetActionName(),
                           /*share_action_type=*/(*iter)->GetActionType(),
                           /*secondary_display_name=*/std::nullopt,
                           /*activity_name=*/std::nullopt,
                           /*is_dlp_blocked=*/false);
    }
    ++iter;
  }
  return targets;
}

void SharesheetService::LoadAppIcons(
    std::vector<apps::IntentLaunchInfo> intent_launch_info,
    std::vector<TargetInfo> targets,
    size_t index,
    SharesheetServiceIconLoaderCallback callback) {
  if (index >= intent_launch_info.size()) {
    std::move(callback).Run(std::move(targets));
    return;
  }

  // Making a copy because we move |intent_launch_info| out below.
  auto app_id = intent_launch_info[index].app_id;
  uint32_t icon_effects = app_service_proxy_->GetIconEffects(app_id);
  if (intent_launch_info[index].is_dlp_blocked) {
    icon_effects |= apps::IconEffects::kBlocked;
  }
  app_service_proxy_->LoadIconWithIconEffects(
      app_id, icon_effects, apps::IconType::kStandard, kIconSize,
      /*allow_placeholder_icon=*/false,
      base::BindOnce(&SharesheetService::OnIconLoaded,
                     weak_factory_.GetWeakPtr(), std::move(intent_launch_info),
                     std::move(targets), index, std::move(callback)));
}

void SharesheetService::OnIconLoaded(
    std::vector<apps::IntentLaunchInfo> intent_launch_info,
    std::vector<TargetInfo> targets,
    size_t index,
    SharesheetServiceIconLoaderCallback callback,
    apps::IconValuePtr icon_value) {
  const auto& launch_entry = intent_launch_info[index];
  const auto& app_type =
      app_service_proxy_->AppRegistryCache().GetAppType(launch_entry.app_id);
  auto target_type = TargetType::kUnknown;
  if (app_type == apps::AppType::kArc) {
    target_type = TargetType::kArcApp;
  } else if (app_type == apps::AppType::kWeb ||
             app_type == apps::AppType::kSystemWeb) {
    target_type = TargetType::kWebApp;
  }

  app_service_proxy_->AppRegistryCache().ForOneApp(
      launch_entry.app_id, [&launch_entry, &targets, &icon_value,
                            &target_type](const apps::AppUpdate& update) {
        gfx::ImageSkia image_skia =
            (icon_value && icon_value->icon_type == apps::IconType::kStandard)
                ? icon_value->uncompressed
                : gfx::ImageSkia();
        targets.emplace_back(
            /*type=*/target_type, /*icon=*/image_skia,
            /*launch_name=*/base::UTF8ToUTF16(launch_entry.app_id),
            /*display_name=*/base::UTF8ToUTF16(update.Name()),
            /*share_action_type=*/std::nullopt,
            /*secondary_display_name=*/
            base::UTF8ToUTF16(launch_entry.activity_label),
            /*activity_name=*/launch_entry.activity_name,
            /*is_dlp_blocked=*/launch_entry.is_dlp_blocked);
      });

  LoadAppIcons(std::move(intent_launch_info), std::move(targets), index + 1,
               std::move(callback));
}

void SharesheetService::OnAppIconsLoaded(
    apps::IntentPtr intent,
    GetNativeWindowCallback get_native_window_callback,
    DeliveredCallback delivered_callback,
    CloseCallback close_callback,
    std::vector<TargetInfo> targets) {
  gfx::NativeWindow native_window = std::move(get_native_window_callback).Run();
  // Note that checking |native_window| is not sufficient: |widget| can be null
  // even when |native_window| is 'true': https://crbug.com/1375887#c11
  views::Widget* const widget =
      views::Widget::GetWidgetForNativeWindow(native_window);
  if (!widget) {
    LOG(WARNING) << "Window has been closed";
    std::move(delivered_callback).Run(SharesheetResult::kErrorWindowClosed);
    return;
  }

  OnReadyToShowBubble(native_window, std::move(intent),
                      std::move(delivered_callback), std::move(close_callback),
                      std::move(targets));
}

void SharesheetService::OnReadyToShowBubble(
    gfx::NativeWindow native_window,
    apps::IntentPtr intent,
    DeliveredCallback delivered_callback,
    CloseCallback close_callback,
    std::vector<TargetInfo> targets) {
  auto* delegator = GetOrCreateDelegator(native_window);

  RecordTargetCountMetrics(targets);
  RecordShareDataMetrics(intent);

  // If SetSelectedAppForTesting() has been called, immediately launch the app.
  const std::u16string selected_app = GetSelectedApp();
  if (!selected_app.empty()) {
    SharesheetResult result = SharesheetResult::kCancel;
    if (std::ranges::any_of(targets, [selected_app](const auto& target) {
          return (target.type == TargetType::kArcApp ||
                  target.type == TargetType::kWebApp) &&
                 target.launch_name == selected_app;
        })) {
      LaunchApp(selected_app, std::move(intent));
      result = SharesheetResult::kSuccess;
    }

    std::move(delivered_callback).Run(result);
    delegator->OnBubbleClosed(/*share_action_type=*/std::nullopt);
    return;
  }

  delegator->ShowBubble(std::move(targets), std::move(intent),
                        std::move(delivered_callback),
                        std::move(close_callback));
}

void SharesheetService::LaunchApp(const std::u16string& target_name,
                                  apps::IntentPtr intent) {
  app_service_proxy_->LaunchAppWithIntent(
      base::UTF16ToUTF8(target_name),
      apps::GetEventFlags(WindowOpenDisposition::NEW_WINDOW,
                          /*prefer_container=*/true),
      std::move(intent), apps::LaunchSource::kFromSharesheet,
      std::make_unique<apps::WindowInfo>(display::kDefaultDisplayId),
      base::DoNothing());
}

SharesheetServiceDelegator* SharesheetService::GetOrCreateDelegator(
    gfx::NativeWindow native_window) {
  auto* delegator = GetDelegator(native_window);
  if (delegator == nullptr) {
    auto new_delegator =
        std::make_unique<SharesheetServiceDelegator>(native_window, this);
    delegator = new_delegator.get();
    active_delegators_.push_back(std::move(new_delegator));
  }
  return delegator;
}

SharesheetServiceDelegator* SharesheetService::GetDelegator(
    gfx::NativeWindow native_window) {
  auto iter = active_delegators_.begin();
  while (iter != active_delegators_.end()) {
    if ((*iter)->GetNativeWindow() == native_window) {
      return iter->get();
    }
    ++iter;
  }
  return nullptr;
}

void SharesheetService::RecordUserActionMetrics(
    const std::optional<ShareActionType>& share_action_type,
    const std::optional<std::u16string>& app_name) {
  // One of the two optional fields must be set.
  CHECK(share_action_type || app_name);

  if (share_action_type) {
    switch (share_action_type.value()) {
      case ShareActionType::kExample:
        // This is a test. Do nothing.
        return;
      case ShareActionType::kNearbyShare:
        SharesheetMetrics::RecordSharesheetActionMetrics(
            SharesheetMetrics::UserAction::kNearbyAction);
        return;
      case ShareActionType::kDriveShare:
        SharesheetMetrics::RecordSharesheetActionMetrics(
            SharesheetMetrics::UserAction::kDriveAction);
        return;
      case ShareActionType::kCopyToClipboardShare:
        SharesheetMetrics::RecordSharesheetActionMetrics(
            SharesheetMetrics::UserAction::kCopyAction);
        return;
      default:
        NOTREACHED();
    }
  }

  if (app_name) {
    // Should be an app if we reached here.
    auto app_type = app_service_proxy_->AppRegistryCache().GetAppType(
        base::UTF16ToUTF8(app_name.value()));
    switch (app_type) {
      case apps::AppType::kArc:
        SharesheetMetrics::RecordSharesheetActionMetrics(
            SharesheetMetrics::UserAction::kArc);
        return;
      case apps::AppType::kWeb:
      // TODO(crbug.com/40172532): Add a separate metrics for System Web Apps if
      // needed.
      case apps::AppType::kSystemWeb:
        SharesheetMetrics::RecordSharesheetActionMetrics(
            SharesheetMetrics::UserAction::kWeb);
        return;
      case apps::AppType::kCrostini:
      case apps::AppType::kChromeApp:
      case apps::AppType::kPluginVm:
      case apps::AppType::kRemote:
      case apps::AppType::kBorealis:
      case apps::AppType::kBruschetta:
      case apps::AppType::kExtension:
      case apps::AppType::kUnknown:
        NOTREACHED();
    }
  }
}

void SharesheetService::RecordTargetCountMetrics(
    const std::vector<TargetInfo>& targets) {
  int arc_app_count = 0;
  int web_app_count = 0;
  for (const auto& target : targets) {
    switch (target.type) {
      case TargetType::kArcApp:
        ++arc_app_count;
        break;
      case TargetType::kWebApp:
        ++web_app_count;
        break;
      case TargetType::kAction:
        break;
      case TargetType::kUnknown:
        NOTREACHED();
    }
  }
  SharesheetMetrics::RecordSharesheetArcAppCount(arc_app_count);
  SharesheetMetrics::RecordSharesheetWebAppCount(web_app_count);
}

void SharesheetService::RecordShareDataMetrics(const apps::IntentPtr& intent) {
  // Record file count.
  SharesheetMetrics::RecordSharesheetFilesSharedCount(intent->files.size());
}

}  // namespace sharesheet