// 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 "chromeos/ash/components/http_auth_dialog/http_auth_dialog.h"

#include <vector>

#include "base/debug/dump_without_crashing.h"
#include "base/no_destructor.h"
#include "base/observer_list.h"
#include "base/task/sequenced_task_runner.h"
#include "components/constrained_window/constrained_window_views.h"
#include "components/strings/grit/components_strings.h"
#include "components/url_formatter/elide_url.h"
#include "components/web_modal/web_contents_modal_dialog_manager.h"
#include "content/public/browser/browser_thread.h"
#include "services/network/public/cpp/is_potentially_trustworthy.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/mojom/dialog_button.mojom.h"
#include "ui/base/mojom/ui_base_types.mojom-shared.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/layout/box_layout_view.h"
#include "ui/views/layout/layout_provider.h"
#include "ui/views/layout/table_layout_view.h"

namespace ash {

namespace {

// This dialog is used in place of the browser http auth dialog when
// `g_enable_count` >= 1.
static int g_enable_count = 0;

// The distance between vertical controls.
constexpr int kDistanceControlListVertical = 12;

// All HttpAuthDialogs should be tracked in this global singleton for testing.
using HttpAuthDialogVector = std::vector<HttpAuthDialog*>;
HttpAuthDialogVector& GetAllDialogs() {
  static base::NoDestructor<HttpAuthDialogVector> instance;
  return *instance;
}

// All observers should be tracked in this global singleton.
using Observers = base::ObserverList<HttpAuthDialog::Observer>;
Observers& GetObservers() {
  static base::NoDestructor<Observers> instance;
  return *instance;
}

// Computes `authority` and `explanation`.
void GetDialogStrings(const GURL& request_url,
                      const net::AuthChallengeInfo& auth_info,
                      std::u16string* authority,
                      std::u16string* explanation) {
  GURL authority_url;

  if (auth_info.is_proxy) {
    *authority = l10n_util::GetStringFUTF16(
        IDS_LOGIN_DIALOG_PROXY_AUTHORITY,
        url_formatter::FormatUrlForSecurityDisplay(
            auth_info.challenger.GetURL(), url_formatter::SchemeDisplay::SHOW));
    authority_url = auth_info.challenger.GetURL();
  } else {
    *authority = url_formatter::FormatUrlForSecurityDisplay(request_url);
    authority_url = request_url;
  }

  if (!network::IsUrlPotentiallyTrustworthy(authority_url)) {
    *explanation = l10n_util::GetStringUTF16(IDS_LOGIN_DIALOG_NOT_PRIVATE);
  } else {
    explanation->clear();
  }
}

}  // namespace

HttpAuthDialog::~HttpAuthDialog() {
  // Book-keeping for test-only data-structures.
  auto& dialogs = GetAllDialogs();
  auto it = std::find(dialogs.begin(), dialogs.end(), this);
  DCHECK(it != dialogs.end());
  dialogs.erase(it);

  // The widget will be destroyed soon, so we must first clear raw_ptrs owned by
  // the widget.
  dialog_view_ = nullptr;
}

HttpAuthDialog::ScopedEnabler::ScopedEnabler() {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  ++g_enable_count;
}

HttpAuthDialog::ScopedEnabler::~ScopedEnabler() {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  --g_enable_count;
}

std::unique_ptr<HttpAuthDialog::ScopedEnabler> HttpAuthDialog::Enable() {
  return std::make_unique<ScopedEnabler>();
}

// static
bool HttpAuthDialog::IsEnabled() {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  return g_enable_count >= 1;
}

// static
std::unique_ptr<HttpAuthDialog> HttpAuthDialog::Create(
    const net::AuthChallengeInfo& auth_info,
    content::WebContents* web_contents,
    const GURL& url,
    content::LoginDelegate::LoginAuthRequiredCallback auth_required_callback) {
  // This class cannot handle UI-less auth dialog requests.
  if (!web_contents) {
    return nullptr;
  }

  // Anchor to the outermost WebContents, for e.g. embedded <webview>s.
  web_contents = web_contents->GetOutermostWebContents();

  // Skip if the WebContents instance is not prepared to show a dialog.
  if (!web_modal::WebContentsModalDialogManager::FromWebContents(
          web_contents)) {
    LOG(ERROR) << "Skipping HttpAuthDialog, url=" << url.possibly_invalid_spec()
               << ", web_contents?" << !!web_contents;
    base::debug::DumpWithoutCrashing();
    return nullptr;
  }

  // The constructor is private. There is no portable way to expose the
  // constructor to std::make_unique.
  return base::WrapUnique(new HttpAuthDialog(
      auth_info, web_contents, url, std::move(auth_required_callback)));
}

// static
void HttpAuthDialog::AddObserver(Observer* observer) {
  GetObservers().AddObserver(observer);
}

// static
void HttpAuthDialog::RemoveObserver(Observer* observer) {
  GetObservers().RemoveObserver(observer);
}

// static
std::vector<HttpAuthDialog*> HttpAuthDialog::GetAllDialogsForTest() {
  return GetAllDialogs();
}

void HttpAuthDialog::SupplyCredentialsForTest(std::u16string_view username,
                                              std::u16string_view password) {
  dialog_view_->SetCredentialsForTest(std::move(username), std::move(password));
  dialog_delegate_.AcceptDialog();
}

void HttpAuthDialog::CancelForTest() {
  dialog_delegate_.CancelDialog();
}

HttpAuthDialog::DialogView::DialogView(std::u16string_view authority,
                                       std::u16string_view explanation) {
  std::u16string authority_string(authority);
  std::u16string explanation_string(explanation);
  views::LayoutProvider* provider = views::LayoutProvider::Get();
  SetLayoutManager(std::make_unique<views::BoxLayout>(
      views::BoxLayout::Orientation::kVertical,
      provider->GetDialogInsetsForContentType(
          views::DialogContentType::kText, views::DialogContentType::kControl),
      provider->GetDistanceMetric(views::DISTANCE_UNRELATED_CONTROL_VERTICAL)));

  auto* authority_container =
      AddChildView(std::make_unique<views::BoxLayoutView>());
  authority_container->SetOrientation(views::BoxLayout::Orientation::kVertical);
  auto* authority_label =
      authority_container->AddChildView(std::make_unique<views::Label>(
          authority_string, views::style::CONTEXT_LABEL,
          views::style::STYLE_PRIMARY));
  authority_label->SetMultiLine(true);
  constexpr int kMessageWidth = 320;
  authority_label->SetMaximumWidth(kMessageWidth);
  authority_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
  authority_label->SetAllowCharacterBreak(true);
  if (!explanation_string.empty()) {
    auto* explanation_label =
        authority_container->AddChildView(std::make_unique<views::Label>(
            explanation_string, views::style::CONTEXT_LABEL,
            views::style::STYLE_SECONDARY));
    explanation_label->SetMultiLine(true);
    explanation_label->SetMaximumWidth(kMessageWidth);
    explanation_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
  }

  auto* fields_container =
      AddChildView(std::make_unique<views::TableLayoutView>());
  fields_container
      ->AddColumn(views::LayoutAlignment::kStart,
                  views::LayoutAlignment::kCenter,
                  views::TableLayout::kFixedSize,
                  views::TableLayout::ColumnSize::kUsePreferred, 0, 0)
      .AddPaddingColumn(
          views::TableLayout::kFixedSize,
          provider->GetDistanceMetric(views::DISTANCE_RELATED_LABEL_HORIZONTAL))
      .AddColumn(views::LayoutAlignment::kStretch,
                 views::LayoutAlignment::kStretch, 1.0,
                 views::TableLayout::ColumnSize::kFixed, 0, 0)
      .AddRows(1, views::TableLayout::kFixedSize)
      .AddPaddingRow(views::TableLayout::kFixedSize,
                     kDistanceControlListVertical)
      .AddRows(1, views::TableLayout::kFixedSize);
  auto* username_label =
      fields_container->AddChildView(std::make_unique<views::Label>(
          l10n_util::GetStringUTF16(IDS_LOGIN_DIALOG_USERNAME_FIELD),
          views::style::CONTEXT_LABEL, views::style::STYLE_PRIMARY));
  username_field_ =
      fields_container->AddChildView(std::make_unique<views::Textfield>());
  username_field_->GetViewAccessibility().SetName(*username_label);
  auto* password_label =
      fields_container->AddChildView(std::make_unique<views::Label>(
          l10n_util::GetStringUTF16(IDS_LOGIN_DIALOG_PASSWORD_FIELD),
          views::style::CONTEXT_LABEL, views::style::STYLE_PRIMARY));
  password_field_ =
      fields_container->AddChildView(std::make_unique<views::Textfield>());
  password_field_->GetViewAccessibility().SetName(*password_label);
  password_field_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
}

HttpAuthDialog::DialogView::~DialogView() = default;

// Access the data in the username/password text fields.
std::u16string HttpAuthDialog::DialogView::GetUsername() const {
  return std::u16string(username_field_->GetText());
}

std::u16string HttpAuthDialog::DialogView::GetPassword() const {
  return std::u16string(password_field_->GetText());
}

void HttpAuthDialog::DialogView::SetCredentialsForTest(
    std::u16string_view username,
    std::u16string_view password) {
  std::u16string username_string(username);
  std::u16string password_string(password);
  username_field_->SetText(username_string);
  password_field_->SetText(password_string);
}

views::View* HttpAuthDialog::DialogView::GetInitiallyFocusedView() {
  return username_field_;
}

HttpAuthDialog::HttpAuthDialog(
    const net::AuthChallengeInfo& auth_info,
    content::WebContents* web_contents,
    const GURL& url,
    content::LoginDelegate::LoginAuthRequiredCallback auth_required_callback)
    : callback_(std::move(auth_required_callback)),
      web_contents_(web_contents) {
  CHECK(!callback_.is_null());
  GetAllDialogs().push_back(this);

  dialog_delegate_.SetButtonLabel(
      ui::mojom::DialogButton::kOk,
      l10n_util::GetStringUTF16(IDS_LOGIN_DIALOG_OK_BUTTON_LABEL));

  dialog_delegate_.SetAcceptCallback(base::BindOnce(
      [](base::WeakPtr<HttpAuthDialog> dialog) {
        if (!dialog) {
          return;
        }

        dialog->SupplyCredentials(dialog->dialog_view_->GetUsername(),
                                  dialog->dialog_view_->GetPassword());
      },
      weak_factory_.GetWeakPtr()));

  auto close_callback =
      base::BindOnce(&HttpAuthDialog::Cancel, weak_factory_.GetWeakPtr());

  // WindowClosing callback is guaranteed to be called regardless of whether the
  // dialog is closed by the user or the OS.
  dialog_delegate_.RegisterWindowClosingCallback(std::move(close_callback));
  dialog_delegate_.SetOwnershipOfNewWidget(
      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);

  dialog_delegate_.SetModalType(ui::mojom::ModalType::kChild);
  dialog_delegate_.SetShowCloseButton(false);
  dialog_delegate_.SetTitle(l10n_util::GetStringUTF16(IDS_LOGIN_DIALOG_TITLE));

  std::u16string authority;
  std::u16string explanation;
  GetDialogStrings(url, auth_info, &authority, &explanation);
  dialog_view_ = dialog_delegate_.SetContentsView(
      std::make_unique<DialogView>(authority, explanation));
  dialog_delegate_.SetInitiallyFocusedView(
      dialog_view_->GetInitiallyFocusedView());

  dialog_widget_ = constrained_window::ShowWebModalDialogViewsOwned(
      &dialog_delegate_, web_contents,
      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);

  NotifyShownAsync(web_contents_);
}

void HttpAuthDialog::SupplyCredentials(std::u16string_view username,
                                       std::u16string_view password) {
  std::u16string username_string(username);
  std::u16string password_string(password);
  net::AuthCredentials credentials(username_string, password_string);
  CHECK(!callback_.is_null());
  NotifySuppliedAsync(web_contents_);

  // Running `callback_` can result in synchronous destruction of this object.
  // We dispatch the call to avoid re-entrancy, as this method itself can be
  // synchronously invoked as a callback.
  auto run_callback = base::BindOnce(
      [](base::WeakPtr<HttpAuthDialog> dialog,
         content::LoginDelegate::LoginAuthRequiredCallback callback,
         net::AuthCredentials credentials) {
        if (dialog) {
          std::move(callback).Run(std::move(credentials));
        }
      },
      weak_factory_.GetWeakPtr(), std::move(callback_), std::move(credentials));
  base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE, std::move(run_callback));
}

void HttpAuthDialog::Cancel() {
  NotifyCancelledAsync(web_contents_);

  // Running `callback_` can result in synchronous destruction of this object.
  // We dispatch the call to avoid re-entrancy, as this method itself can be
  // synchronously invoked as a callback.
  auto run_callback = base::BindOnce(
      [](base::WeakPtr<HttpAuthDialog> dialog,
         content::LoginDelegate::LoginAuthRequiredCallback callback) {
        if (dialog) {
          std::move(callback).Run(std::nullopt);
        }
      },
      weak_factory_.GetWeakPtr(), std::move(callback_));
  base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE, std::move(run_callback));
}

// static
void HttpAuthDialog::NotifyShownAsync(content::WebContents* web_contents) {
  auto callback = base::BindOnce(
      [](base::WeakPtr<content::WebContents> web_contents) {
        for (auto& observer : GetObservers()) {
          observer.HttpAuthDialogShown(web_contents ? web_contents.get()
                                                    : nullptr);
        }
      },
      web_contents->GetWeakPtr());
  base::SequencedTaskRunner::GetCurrentDefault()->PostTask(FROM_HERE,
                                                           std::move(callback));
}

//  static
void HttpAuthDialog::NotifySuppliedAsync(content::WebContents* web_contents) {
  auto callback = base::BindOnce(
      [](base::WeakPtr<content::WebContents> web_contents) {
        for (auto& observer : GetObservers()) {
          observer.HttpAuthDialogSupplied(web_contents ? web_contents.get()
                                                       : nullptr);
        }
      },
      web_contents->GetWeakPtr());
  base::SequencedTaskRunner::GetCurrentDefault()->PostTask(FROM_HERE,
                                                           std::move(callback));
}

//  static
void HttpAuthDialog::NotifyCancelledAsync(content::WebContents* web_contents) {
  auto callback = base::BindOnce(
      [](base::WeakPtr<content::WebContents> web_contents) {
        for (auto& observer : GetObservers()) {
          observer.HttpAuthDialogCancelled(web_contents ? web_contents.get()
                                                        : nullptr);
        }
      },
      web_contents->GetWeakPtr());
  base::SequencedTaskRunner::GetCurrentDefault()->PostTask(FROM_HERE,
                                                           std::move(callback));
}

}  // namespace ash