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

#ifndef CHROME_BROWSER_UI_WEBUI_PASSWORD_MANAGER_PASSWORD_MANAGER_UI_HANDLER_H_
#define CHROME_BROWSER_UI_WEBUI_PASSWORD_MANAGER_PASSWORD_MANAGER_UI_HANDLER_H_

#include "base/containers/flat_map.h"
#include "base/memory/weak_ptr.h"
#include "base/scoped_observation.h"
#include "chrome/browser/extensions/api/passwords_private/passwords_private_delegate.h"
#include "chrome/browser/password_manager/password_change/password_change_from_checkup_delegate.h"
#include "chrome/browser/ui/webui/password_manager/password_manager.mojom.h"
#include "components/password_manager/core/browser/ui/saved_passwords_presenter.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"

namespace extensions {
class PasswordsPrivateDelegate;
}

namespace content {
class WebContents;
}

// This class acts as the IPC proxy between the Password Manager
// WebUI (Renderer process) and the Browser process.
//
// Rules:
// 1. Unpack Mojo requests, delegate to backend components, and pack Mojo
//    responses.
// 2. Do not implement core logic, conditional flows, or direct system
//    interactions here.
// 3. TODO(crbug.com/432409279): Currently, most operations are delegated to
//    PasswordsPrivateDelegate as part of the migration from the legacy
//    extensions API. In the future, the backend logic should be broken down
//    and delegated to cohesive domain services instead.

class PasswordManagerUIHandler
    : public password_manager::mojom::PageHandler,
      public extensions::PasswordsPrivateDelegate::Observer {
 public:
  PasswordManagerUIHandler(
      mojo::PendingReceiver<password_manager::mojom::PageHandler> receiver,
      mojo::PendingRemote<password_manager::mojom::Page> page,
      scoped_refptr<extensions::PasswordsPrivateDelegate>
          passwords_private_delegate,
      content::WebContents* web_contents);

  PasswordManagerUIHandler(const PasswordManagerUIHandler&) = delete;
  PasswordManagerUIHandler& operator=(const PasswordManagerUIHandler&) = delete;

  ~PasswordManagerUIHandler() override;

  // password_manager::mojom::PageHandler:
  void ExtendAuthValidity() override;

  void DeleteAllPasswordManagerData(
      DeleteAllPasswordManagerDataCallback callback) override;

  void CopyPlaintextBackupPassword(
      int id,
      CopyPlaintextBackupPasswordCallback callback) override;

  void RemoveBackupPassword(int id) override;

  void RemovePasswordException(int id) override;

  void StartBulkPasswordCheck() override;

  void MovePasswordsToAccount(const std::vector<int>& ids) override;

  void ResetImporter(bool delete_file, ResetImporterCallback callback) override;

  void GetActorLoginPermissions(
      GetActorLoginPermissionsCallback callback) override;

  void RevokeActorLoginPermission(
      password_manager::mojom::ActorLoginPermissionPtr site) override;

  void ChangePasswordManagerPin(
      ChangePasswordManagerPinCallback callback) override;

  void IsPasswordManagerPinAvailable(
      IsPasswordManagerPinAvailableCallback callback) override;

  void ShowAddShortcutDialog() override;

  void IsAccountStorageActive(IsAccountStorageActiveCallback callback) override;

  void SwitchBiometricAuthBeforeFillingState(
      SwitchBiometricAuthBeforeFillingStateCallback callback) override;

  void StartPasswordChange(int credential_id) override;

  void StopPasswordChange(int credential_id) override;

  void OpenPasswordChangeTab(int credential_id) override;

  void GetPasswordManagerActionableError(
      GetPasswordManagerActionableErrorCallback callback) override;

  void ShowLastExportedFileInShell() override;

  void DisconnectCloudAuthenticator(
      DisconnectCloudAuthenticatorCallback callback) override;

  void IsConnectedToCloudAuthenticator(
      IsConnectedToCloudAuthenticatorCallback callback) override;

  void UndoRemoveSavedPasswordOrException() override;

  void RequestPasswordsExport(RequestPasswordsExportCallback callback) override;

  void GetPasswordsExportProgress(
      GetPasswordsExportProgressCallback callback) override;

  void ImportPasswords(password_manager::mojom::PasswordStoreSet to_store,
                       ImportPasswordsCallback callback) override;

  void ContinueImport(const std::vector<int32_t>& selected_ids,
                      ContinueImportCallback callback) override;

  void StartTrustedVaultUnlock() override;

  // extensions::PasswordsPrivateDelegate::Observer:
  void OnPasswordsExportProgress(password_manager::ExportProgressStatus status,
                                 const std::string& folder_name) override;

 private:
  password_manager::SavedPasswordsPresenter* GetSavedPasswordsPresenter();

  void OnPasswordAutomaticChangeStateUpdated(
      int credential_id,
      PasswordChangeFromCheckupDelegate::PasswordAutomaticChangeState state);

  raw_ptr<content::WebContents> web_contents_;
  scoped_refptr<extensions::PasswordsPrivateDelegate>
      passwords_private_delegate_;

  base::ScopedObservation<extensions::PasswordsPrivateDelegate,
                          extensions::PasswordsPrivateDelegate::Observer>
      passwords_private_delegate_observation_{this};

  base::flat_map<int, base::WeakPtr<PasswordChangeFromCheckupDelegate>>
      password_change_from_checkup_delegates_;

  // NOTE: These are located at the end of the list of member variables to
  // ensure the WebUI page is disconnected before other members are destroyed.
  mojo::Receiver<password_manager::mojom::PageHandler> receiver_;
  mojo::Remote<password_manager::mojom::Page> page_;

  base::WeakPtrFactory<PasswordManagerUIHandler> weak_ptr_factory_{this};
};

#endif  // CHROME_BROWSER_UI_WEBUI_PASSWORD_MANAGER_PASSWORD_MANAGER_UI_HANDLER_H_