// 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 "components/permissions/permissions_client.h"

#include "base/functional/callback.h"
#include "build/build_config.h"
#include "components/content_settings/core/common/content_settings.h"
#include "components/omnibox/common/omnibox_feature_configs.h"
#include "components/permissions/permission_request_enums.h"
#include "components/permissions/permission_uma_util.h"
#include "components/permissions/resolvers/permission_prompt_options.h"
#include "content/public/browser/web_contents.h"

#if !BUILDFLAG(IS_ANDROID)
#include "ui/gfx/vector_icon_types.h"
#endif

namespace permissions {
namespace {
PermissionsClient* g_client = nullptr;
}

PermissionsClient::PermissionsClient() {
  DCHECK(!g_client);
  g_client = this;
}

PermissionsClient::~PermissionsClient() {
  g_client = nullptr;
}

// static
PermissionsClient* PermissionsClient::Get() {
  DCHECK(g_client);
  return g_client;
}

// static
bool PermissionsClient::AllowEmbeddedPermissionPromptForSurface(
    content::WebContents* web_contents) {
  if (web_contents && Get() && Get()->IsOmniboxEverywhere(web_contents)) {
    return true;
  }
  return base::FeatureList::IsEnabled(
      omnibox_feature_configs::kEmbeddedPermissionEnabled);
}

bool PermissionsClient::IsOmniboxEverywhere(
    content::WebContents* web_contents) {
  return false;
}

double PermissionsClient::GetSiteEngagementScore(
    content::BrowserContext* browser_context,
    const GURL& origin) {
  return 0.0;
}

void PermissionsClient::AreSitesImportant(
    content::BrowserContext* browser_context,
    std::vector<std::pair<url::Origin, bool>>* origins) {
  for (auto& entry : *origins) {
    entry.second = false;
  }
}

bool PermissionsClient::IsCookieDeletionDisabled(
    content::BrowserContext* browser_context,
    const GURL& origin) {
  return false;
}

void PermissionsClient::GetUkmSourceId(
    ContentSettingsType permission_type,
    content::BrowserContext* browser_context,
    content::RenderFrameHost* render_frame_host,
    const GURL& requesting_origin,
    GetUkmSourceIdCallback callback) {
  std::move(callback).Run(std::nullopt);
}

IconId PermissionsClient::GetOverrideIconId(RequestType request_type) {
#if BUILDFLAG(IS_ANDROID)
  return 0;
#else
  return gfx::VectorIcon::EmptyIcon();
#endif
}

std::vector<std::unique_ptr<PermissionUiSelector>>
PermissionsClient::CreatePermissionUiSelectors(
    content::BrowserContext* browser_context) {
  return std::vector<std::unique_ptr<PermissionUiSelector>>();
}

void PermissionsClient::TriggerPromptHatsSurveyIfEnabled(
    content::WebContents* web_contents,
    permissions::RequestType request_type,
    std::optional<permissions::PermissionAction> action,
    permissions::PermissionPromptDisposition prompt_disposition,
    permissions::PermissionPromptDispositionReason prompt_disposition_reason,
    permissions::PermissionRequestGestureType gesture_type,
    std::optional<base::TimeDelta> prompt_display_duration,
    bool is_post_prompt,
    const GURL& gurl,
    std::optional<permissions::feature_params::PermissionElementPromptPosition>
        pepc_prompt_position,
    ContentSetting initial_permission_status,
    base::OnceCallback<void()> hats_shown_callback,
    PromptOptions prompt_options) {}

void PermissionsClient::OnPromptResolved(
    const PermissionRequest* request,
    PermissionAction action,
    const PromptOptions& prompt_options,
    PermissionPromptDisposition prompt_disposition,
    PermissionPromptDispositionReason prompt_disposition_reason,
    std::optional<QuietUiReason> quiet_ui_reason,
    base::TimeDelta prompt_display_duration,
    std::optional<permissions::feature_params::PermissionElementPromptPosition>
        pepc_prompt_position,
    ContentSetting initial_permission_status,
    content::WebContents* web_contents) {}

std::optional<bool>
PermissionsClient::HadThreeConsecutiveNotificationPermissionDenies(
    content::BrowserContext* browser_context) {
  return std::nullopt;
}

std::optional<url::Origin> PermissionsClient::GetAutoApprovalOrigin(
    content::BrowserContext* browser_context) {
  return std::nullopt;
}

std::optional<PermissionAction> PermissionsClient::GetAutoApprovalStatus(
    content::BrowserContext* browser_context,
    const GURL& origin) {
  return std::nullopt;
}

std::optional<bool> PermissionsClient::HasPreviouslyAutoRevokedPermission(
    content::BrowserContext* browser_context,
    const GURL& origin,
    ContentSettingsType permission) {
  return std::nullopt;
}

bool PermissionsClient::CanBypassEmbeddingOriginCheck(
    const GURL& requesting_origin,
    const GURL& embedding_origin) {
  return false;
}

std::optional<GURL> PermissionsClient::GetCanonicalOriginOverride(
    const GURL& requesting_origin,
    const GURL& embedding_origin) {
  return std::nullopt;
}

std::optional<GURL> PermissionsClient::GetEmbeddingOriginOverride(
    const GURL& requesting_origin,
    content::RenderFrameHost* render_frame_host) {
  return std::nullopt;
}

bool PermissionsClient::IsPrivilegedInternalWebUIForUIRouting(
    content::WebContents* web_contents) {
  return false;
}

bool PermissionsClient::IsFromNewTabPage(content::WebContents* web_contents,
                                         const GURL& requester,
                                         bool already_overrode_requester) {
  return false;
}

bool PermissionsClient::IsPrivilegedInternalWebUI(
    content::WebContents* web_contents,
    const GURL& requester,
    bool already_overrode_requester) {
  return false;
}

bool PermissionsClient::IsPrivilegedInternalWebUIOrNewTabPage(
    content::WebContents* web_contents,
    const GURL& requester,
    bool already_overrode_requester) {
  return IsPrivilegedInternalWebUI(web_contents, requester,
                                   already_overrode_requester) ||
         IsFromNewTabPage(web_contents, requester, already_overrode_requester);
}

permissions::PermissionIgnoredReason PermissionsClient::DetermineIgnoreReason(
    content::WebContents* web_contents) {
  return permissions::PermissionIgnoredReason::UNKNOWN;
}

#if BUILDFLAG(IS_ANDROID)
bool PermissionsClient::IsDseOrigin(content::BrowserContext* browser_context,
                                    const url::Origin& origin) {
  return false;
}

std::unique_ptr<PermissionsClient::PermissionMessageDelegate>
PermissionsClient::MaybeCreateMessageUI(
    content::WebContents* web_contents,
    const PermissionRequest& request,
    base::WeakPtr<PermissionPromptAndroid> prompt) {
  return nullptr;
}

void PermissionsClient::RepromptForAndroidPermissions(
    content::WebContents* web_contents,
    const std::vector<ContentSettingsType>& content_settings_types,
    const std::vector<ContentSettingsType>& filtered_content_settings_types,
    const std::vector<std::string>& required_permissions,
    const std::vector<std::string>& optional_permissions,
    PermissionsUpdatedCallback callback) {
  std::move(callback).Run(false);
}

int PermissionsClient::MapToJavaDrawableId(int resource_id) {
  return 0;
}
#else
std::unique_ptr<PermissionPrompt> PermissionsClient::CreatePrompt(
    content::WebContents* web_contents,
    PermissionPrompt::Delegate* delegate) {
  return nullptr;
}
#endif

std::unique_ptr<EmbeddedPermissionPromptFlowModel::PromptContentScrim>
PermissionsClient::CreatePromptContentScrim(
    content::WebContents* web_contents,
    EmbeddedPermissionPromptFlowModel* flow_model) {
  return nullptr;
}

bool PermissionsClient::HasDevicePermission(ContentSettingsType type) const {
  return true;
}

bool PermissionsClient::CanRequestDevicePermission(
    ContentSettingsType type) const {
  return false;
}

bool PermissionsClient::IsPermissionAllowedByDevicePolicy(
    content::WebContents* web_contents,
    PermissionSetting setting,
    const content_settings::SettingInfo& info,
    ContentSettingsType type) const {
  return false;
}

bool PermissionsClient::IsPermissionBlockedByDevicePolicy(
    content::WebContents* web_contents,
    PermissionSetting setting,
    const content_settings::SettingInfo& info,
    ContentSettingsType type) const {
  return false;
}

bool PermissionsClient::IsSystemDenied(ContentSettingsType type) const {
  return false;
}

bool PermissionsClient::CanPromptSystemPermission(
    ContentSettingsType type) const {
  return false;
}

bool PermissionsClient::IsActorOperatingOnWebContents(
    content::WebContents* web_contents) const {
  return false;
}

favicon::FaviconService* PermissionsClient::GetFaviconService(
    content::BrowserContext* browser_context) {
  return nullptr;
}

}  // namespace permissions