// Copyright 2022 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/printing/printer_query_oop.h"

#include <memory>
#include <utility>

#include "base/check_op.h"
#include "base/strings/utf_string_conversions.h"
#include "base/types/expected.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/printing/oop_features.h"
#include "chrome/browser/printing/print_backend_service_manager.h"
#include "chrome/browser/printing/print_job_worker_oop.h"
#include "components/device_event_log/device_event_log.h"
#include "content/public/browser/global_routing_id.h"
#include "content/public/browser/web_contents.h"
#include "printing/buildflags/buildflags.h"

namespace printing {

PrinterQueryOop::PrinterQueryOop(content::GlobalRenderFrameHostId rfh_id)
    : PrinterQuery(rfh_id) {}

PrinterQueryOop::~PrinterQueryOop() = default;

std::unique_ptr<PrintJobWorker> PrinterQueryOop::TransferContextToNewWorker(
    PrintJob* print_job) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  // TODO(crbug.com/40256381)  Do extra setup on the worker as needed for
  // supporting OOP system print dialogs.
  return CreatePrintJobWorkerOop(print_job);
}

#if BUILDFLAG(IS_WIN)
void PrinterQueryOop::UpdatePrintableArea(
    PrintSettings* print_settings,
    OnDidUpdatePrintableAreaCallback callback) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  std::string printer_name = base::UTF16ToUTF8(print_settings->device_name());
  PRINTER_LOG(EVENT) << "Updating paper printable area via service for "
                     << printer_name;

  PrintBackendServiceManager& service_mgr =
      PrintBackendServiceManager::GetInstance();

  // Caller is required to ensure `print_settings` stays alive until `callback`
  // runs.
  service_mgr.GetPaperPrintableArea(
      printer_name, print_settings->requested_media(),
      base::BindOnce(&PrinterQueryOop::OnDidGetPaperPrintableArea,
                     weak_factory_.GetWeakPtr(), print_settings,
                     std::move(callback)));
}
#endif

void PrinterQueryOop::SetClientId(
    PrintBackendServiceManager::ClientId client_id) {
  query_with_ui_client_id_ = client_id;
}

void PrinterQueryOop::OnDidUseDefaultSettings(
    SettingsCallback callback,
    base::expected<PrintSettings, mojom::ResultCode> print_settings) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  mojom::ResultCode result;
  if (!print_settings.has_value()) {
    result = print_settings.error();
    DCHECK_NE(result, mojom::ResultCode::kSuccess);
    PRINTER_LOG(ERROR) << "Error trying to use default settings via service: "
                       << result;

    // TODO(crbug.com/40561724)  Fill in support for handling of access-denied
    // result code.  Blocked on crbug.com/1243873 for Windows.
  } else {
    VLOG(1) << "Use default settings from service complete";
    result = mojom::ResultCode::kSuccess;
    printing_context()->SetPrintSettings(print_settings.value());
  }

  InvokeSettingsCallback(std::move(callback), result);
}

#if BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)
void PrinterQueryOop::OnDidAskUserForSettings(
    SettingsCallback callback,
    base::expected<PrintSettings, mojom::ResultCode> print_settings) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  mojom::ResultCode result;
  if (print_settings.has_value()) {
    VLOG(1) << "Ask user for settings from service complete";
    result = mojom::ResultCode::kSuccess;
    printing_context()->SetPrintSettings(print_settings.value());

    // Use the same PrintBackendService for querying and printing, so that the
    // same device context can be used with both.
    print_document_client_id_ =
        PrintBackendServiceManager::GetInstance()
            .RegisterPrintDocumentClientReusingClientRemote(
                *query_with_ui_client_id_);
    if (!print_document_client_id_.has_value()) {
      // A failure after getting settings, override result to failure.
      result = mojom::ResultCode::kFailed;
      PRINTER_LOG(ERROR)
          << "Error after getting settings due to client registration failure; "
             "service or renderer likely has terminated";
    }
  } else {
    result = print_settings.error();
    DCHECK_NE(result, mojom::ResultCode::kSuccess);
    if (result != mojom::ResultCode::kCanceled) {
      PRINTER_LOG(ERROR) << "Error getting settings from user via service: "
                         << result;
    }

    // TODO(crbug.com/40561724)  Fill in support for handling of access-denied
    // result code.  Blocked on crbug.com/1243873 for Windows.
  }

  InvokeSettingsCallback(std::move(callback), result);
}
#else   // BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)
void PrinterQueryOop::OnDidAskUserForSettings(
    SettingsCallback callback,
    std::unique_ptr<PrintSettings> new_settings,
    mojom::ResultCode result) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  if (result == mojom::ResultCode::kSuccess) {
    // Want the same PrintBackend service as the query so that we use the same
    // device context.
    print_document_client_id_ =
        PrintBackendServiceManager::GetInstance()
            .RegisterPrintDocumentClientReusingClientRemote(
                *query_with_ui_client_id_);
    if (!print_document_client_id_.has_value()) {
      // A failure after getting settings, override result to failure.
      result = mojom::ResultCode::kFailed;
      PRINTER_LOG(ERROR)
          << "Error after getting settings due to client registration failure; "
             "service or renderer likely has terminated";
    }
  }
  std::move(callback).Run(std::move(new_settings), result);
}
#endif  // BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)

void PrinterQueryOop::UseDefaultSettings(SettingsCallback callback) {
#if BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)
  CHECK(query_with_ui_client_id_.has_value());

  PRINTER_LOG(EVENT) << "Using printer default settings via service";

  // Any settings selected from the system dialog could need to be retained
  // for printing, so establish a printing context.
  CHECK(!context_id_.has_value());
  SendEstablishPrintingContext(*query_with_ui_client_id_,
                               /*printer_name=*/std::string());
  SendUseDefaultSettings(std::move(callback));
#else
  // `PrintingContextLinux::UseDefaultSettings()` is to be called prior to
  // `AskUserForSettings()` to establish a base device context.  If the system
  // print dialog will be invoked from within the browser process, then that
  // default setup needs to happen in browser as well.
  PrinterQuery::UseDefaultSettings(std::move(callback));
#endif
}

void PrinterQueryOop::GetSettingsWithUI(uint32_t document_page_count,
                                        bool has_selection,
                                        bool is_scripted,
                                        SettingsCallback callback) {
  // Save the print target type from the settings, since this will be needed
  // later when printing is started.
  print_from_system_dialog_ = true;

#if BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)
  PRINTER_LOG(EVENT) << "Getting printer settings from user via service";
  SendAskUserForSettings(document_page_count, has_selection, is_scripted,
                         std::move(callback));
#else
  // Invoke the browser version of getting settings with the system UI:
  //   - macOS:  It is impossible to invoke a system dialog UI from a service
  //       utility and have that dialog be application modal for a window that
  //       was launched by the browser process.
  //   - Linux:  TODO(crbug.com/40561724)  Determine if Linux Wayland can be
  //   made
  //       to have a system dialog be modal against an application window in the
  //       browser process.
  //   - Other platforms don't have a system print UI or do not use OOP
  //     printing, so this does not matter.
  PrinterQuery::GetSettingsWithUI(
      document_page_count, has_selection, is_scripted,
      base::BindOnce(&PrinterQueryOop::OnDidAskUserForSettings,
                     weak_factory_.GetWeakPtr(), std::move(callback)));
#endif
}

void PrinterQueryOop::UpdatePrintSettings(base::Value::Dict new_settings,
                                          SettingsCallback callback) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  // Do not take a const reference, as `new_settings` will be modified below.
  std::string device_name = *new_settings.FindString(kSettingDeviceName);

  // Remember if this is from system print dialog, since this will be needed
  // later when printing is started.
  print_from_system_dialog_ =
      new_settings.FindBool(kSettingShowSystemDialog).value_or(false);

  // A device name is required for printing documents. If the device name is
  // empty then this is for a system print dialog, for which a destination is
  // not yet known.
  PrintBackendServiceManager& service_mgr =
      PrintBackendServiceManager::GetInstance();
  PrintBackendServiceManager::ClientId client_id;
  std::string printer_name;
  if (print_from_system_dialog_) {
    CHECK(!print_document_client_id_.has_value());
    client_id = *query_with_ui_client_id_;
#if BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG) && BUILDFLAG(IS_WIN)
    // `PrintingContextWin::UpdatePrintSettings()` is special because it can
    // invoke `AskUserForSettings()` and cause a system dialog to be displayed.
    // Running a dialog causes an exit to webpage-initiated fullscreen.
    // http://crbug.com/728276
    content::WebContents* web_contents = GetWebContents();
    if (web_contents && web_contents->IsFullscreen()) {
      web_contents->ExitFullscreen(true);
    }
#endif
  } else {
    // Print the document from Print Preview.
    CHECK(!query_with_ui_client_id_.has_value());
    CHECK(!print_document_client_id_.has_value());

    print_document_client_id_ =
        service_mgr.RegisterPrintDocumentClient(device_name);
    client_id = *print_document_client_id_;
    printer_name = device_name;
  }
  SendEstablishPrintingContext(client_id, printer_name);

  VLOG(1) << "Updating print settings via service for " << device_name;

  service_mgr.UpdatePrintSettings(
      client_id, printer_name, *context_id_, std::move(new_settings),
      base::BindOnce(&PrinterQueryOop::OnDidUpdatePrintSettings,
                     weak_factory_.GetWeakPtr(), device_name,
                     std::move(callback)));
}

void PrinterQueryOop::OnDidUpdatePrintSettings(
    const std::string& device_name,
    SettingsCallback callback,
    base::expected<PrintSettings, mojom::ResultCode> print_settings) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  mojom::ResultCode result;
  if (!print_settings.has_value()) {
    result = print_settings.error();
    DCHECK_NE(result, mojom::ResultCode::kSuccess);
    PRINTER_LOG(ERROR) << "Error updating print settings via service for `"
                       << device_name << "`: " << result;

    // `PrintViewManagerBase` owns the client ID, so `PrinterQueryOop` must not
    // unregister it.  Just drop any local reference to it.
    query_with_ui_client_id_.reset();

    // With the failure to update the setting, the registered client must be
    // released.  The context ID is also no longer relevant to use.
    if (print_document_client_id_.has_value()) {
      PrintBackendServiceManager::GetInstance().UnregisterClient(
          print_document_client_id_.value());
      print_document_client_id_.reset();
      CHECK(context_id_.has_value());
      context_id_.reset();
    }

    // TODO(crbug.com/40561724)  Fill in support for handling of access-denied
    // result code.
  } else {
    VLOG(1) << "Update print settings via service complete for " << device_name;
    result = mojom::ResultCode::kSuccess;
    printing_context()->SetPrintSettings(print_settings.value());

    if (query_with_ui_client_id_.has_value()) {
      // Use the same PrintBackendService for querying and printing, so that the
      // same device context can be used with both.
      CHECK(!print_document_client_id_.has_value());
      print_document_client_id_ =
          PrintBackendServiceManager::GetInstance()
              .RegisterPrintDocumentClientReusingClientRemote(
                  *query_with_ui_client_id_);
      if (!print_document_client_id_.has_value()) {
        // A failure after getting settings, override result to failure.
        result = mojom::ResultCode::kFailed;
        PRINTER_LOG(ERROR)
            << "Error after updating print settings due to client registration "
               "failure; service or renderer likely has terminated";
      }
    }
  }
  InvokeSettingsCallback(std::move(callback), result);
}

#if BUILDFLAG(IS_WIN)
void PrinterQueryOop::OnDidGetPaperPrintableArea(
    PrintSettings* print_settings,
    OnDidUpdatePrintableAreaCallback callback,
    const gfx::Rect& printable_area_um) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  if (printable_area_um.IsEmpty()) {
    std::move(callback).Run(/*success=*/false);
    return;
  }

  print_settings->UpdatePrinterPrintableArea(printable_area_um);
  std::move(callback).Run(/*success=*/true);
}
#endif

void PrinterQueryOop::SendEstablishPrintingContext(
    PrintBackendServiceManager::ClientId client_id,
    const std::string& printer_name) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  DCHECK(ShouldPrintJobOop());

  DVLOG(1) << "Establishing printing context for system print";

#if BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)
  content::WebContents* web_contents = GetWebContents();
  gfx::NativeView parent_view =
      web_contents ? web_contents->GetTopLevelNativeWindow() : nullptr;
#endif

  PrintBackendServiceManager& service_mgr =
      PrintBackendServiceManager::GetInstance();

  context_id_ = service_mgr.EstablishPrintingContext(client_id, printer_name
#if BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)
                                                     ,
                                                     parent_view
#endif
  );
}

void PrinterQueryOop::SendUseDefaultSettings(SettingsCallback callback) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  DCHECK(ShouldPrintJobOop());
  CHECK(query_with_ui_client_id_.has_value());

  PrintBackendServiceManager& service_mgr =
      PrintBackendServiceManager::GetInstance();

  service_mgr.UseDefaultSettings(
      *query_with_ui_client_id_, *context_id_,
      base::BindOnce(&PrinterQueryOop::OnDidUseDefaultSettings,
                     weak_factory_.GetWeakPtr(), std::move(callback)));
}

#if BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)
void PrinterQueryOop::SendAskUserForSettings(uint32_t document_page_count,
                                             bool has_selection,
                                             bool is_scripted,
                                             SettingsCallback callback) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  DCHECK(ShouldPrintJobOop());

  if (document_page_count > kMaxPageCount) {
    InvokeSettingsCallback(std::move(callback), mojom::ResultCode::kFailed);
    return;
  }

  content::WebContents* web_contents = GetWebContents();

  // Running a dialog causes an exit to webpage-initiated fullscreen.
  // http://crbug.com/728276
  if (web_contents && web_contents->IsFullscreen()) {
    web_contents->ExitFullscreen(true);
  }

  PrintBackendServiceManager& service_mgr =
      PrintBackendServiceManager::GetInstance();
  service_mgr.AskUserForSettings(
      *query_with_ui_client_id_, *context_id_, document_page_count,
      has_selection, is_scripted,
      base::BindOnce(&PrinterQueryOop::OnDidAskUserForSettings,
                     weak_factory_.GetWeakPtr(), std::move(callback)));
}
#endif  // BUILDFLAG(ENABLE_OOP_BASIC_PRINT_DIALOG)

std::unique_ptr<PrintJobWorkerOop> PrinterQueryOop::CreatePrintJobWorkerOop(
    PrintJob* print_job) {
  return std::make_unique<PrintJobWorkerOop>(
      std::move(printing_context_delegate_), std::move(printing_context_),
      print_document_client_id_, context_id_, print_job,
      print_from_system_dialog_);
}

}  // namespace printing