// Copyright 2017 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/services/printing/pdf_to_emf_converter.h"

#include <limits>
#include <utility>

#include "base/containers/span.h"
#include "base/strings/utf_string_conversions.h"
#include "components/crash/core/common/crash_key.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "pdf/pdf.h"
#include "printing/emf_win.h"
#include "printing/mojom/print.mojom.h"
#include "ui/gfx/win/gdi_util.h"

namespace printing {

PdfToEmfConverter::PdfToEmfConverter(
    base::ReadOnlySharedMemoryRegion pdf_region,
    const PdfRenderSettings& pdf_render_settings)
    : pdf_render_settings_(pdf_render_settings) {
  SetPrintMode();
  LoadPdf(std::move(pdf_region));
}

PdfToEmfConverter::~PdfToEmfConverter() = default;

void PdfToEmfConverter::SetPrintMode() {
  int printing_mode;
  switch (pdf_render_settings_.mode) {
    case PdfRenderSettings::Mode::TEXTONLY:
      printing_mode = chrome_pdf::PrintingMode::kTextOnly;
      break;
    case PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2:
      printing_mode = chrome_pdf::PrintingMode::kPostScript2;
      break;
    case PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3:
      printing_mode = chrome_pdf::PrintingMode::kPostScript3;
      break;
    case PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3_WITH_TYPE42_FONTS:
      printing_mode = chrome_pdf::PrintingMode::kPostScript3WithType42Fonts;
      break;
    case PdfRenderSettings::Mode::EMF_WITH_REDUCED_RASTERIZATION:
      printing_mode = chrome_pdf::PrintingMode::kEmfWithReducedRasterization;
      break;
    default:
      printing_mode = chrome_pdf::PrintingMode::kEmf;
  }
  chrome_pdf::SetPDFUsePrintMode(printing_mode);
}

void PdfToEmfConverter::LoadPdf(base::ReadOnlySharedMemoryRegion pdf_region) {
  if (!pdf_region.IsValid()) {
    LOG(ERROR) << "Invalid PDF passed to PdfToEmfConverter.";
    return;
  }

  size_t size = pdf_region.GetSize();
  if (size <= 0 || size > std::numeric_limits<int>::max())
    return;

  pdf_mapping_ = pdf_region.Map();
  if (!pdf_mapping_.IsValid())
    return;

  int page_count = 0;
  auto pdf_span = pdf_mapping_.GetMemoryAsSpan<const uint8_t>();
  chrome_pdf::GetPDFDocInfo(pdf_span, &page_count, nullptr);
  total_page_count_ = page_count;
}

base::ReadOnlySharedMemoryRegion PdfToEmfConverter::RenderPdfPageToMetafile(
    int page_index,
    bool postscript,
    float* scale_factor) {
  Emf metafile;
  metafile.Init();

  // We need to scale down DC to fit an entire page into DC available area.
  // Current metafile is based on screen DC and have current screen size.
  // Writing outside of those boundaries will result in the cut-off output.
  // On metafiles (this is the case here), scaling down will still record
  // original coordinates and we'll be able to print in full resolution.
  // Before playback we'll need to counter the scaling up that will happen
  // in the service (print_system_win.cc).
  //
  // The postscript driver does not use the metafile size since it outputs
  // postscript rather than a metafile. Instead it uses the printable area
  // sent to RenderPDFPageToDC to determine the area to render. Therefore,
  // don't scale the DC to match the metafile, and send the printer physical
  // offsets to the driver.
  if (!postscript) {
    *scale_factor = gfx::CalculatePageScale(metafile.context(),
                                            pdf_render_settings_.area.right(),
                                            pdf_render_settings_.area.bottom());
    gfx::ScaleDC(metafile.context(), *scale_factor);
  }

  // The underlying metafile is of type Emf and ignores the arguments passed
  // to StartPage().
  metafile.StartPage(gfx::Size(), gfx::Rect(), 1,
                     mojom::PageOrientation::kUpright);
  int offset_x = postscript ? pdf_render_settings_.offsets.x() : 0;
  int offset_y = postscript ? pdf_render_settings_.offsets.y() : 0;

  base::ReadOnlySharedMemoryRegion invalid_emf_region;
  auto pdf_span = pdf_mapping_.GetMemoryAsSpan<const uint8_t>();
  if (!chrome_pdf::RenderPDFPageToDC(
          pdf_span, page_index, metafile.context(),
          pdf_render_settings_.dpi.width(), pdf_render_settings_.dpi.height(),
          pdf_render_settings_.area.x() - offset_x,
          pdf_render_settings_.area.y() - offset_y,
          pdf_render_settings_.area.width(), pdf_render_settings_.area.height(),
          true, false, true, true, pdf_render_settings_.autorotate,
          pdf_render_settings_.use_color)) {
    return invalid_emf_region;
  }
  metafile.FinishPage();
  metafile.FinishDocument();

  const uint32_t size = metafile.GetDataSize();
  base::MappedReadOnlyRegion region_mapping =
      base::ReadOnlySharedMemoryRegion::Create(size);
  if (!region_mapping.IsValid())
    return invalid_emf_region;

  if (!metafile.GetData(region_mapping.mapping.memory(), size))
    return invalid_emf_region;

  return std::move(region_mapping.region);
}

void PdfToEmfConverter::ConvertPage(uint32_t page_index,
                                    ConvertPageCallback callback) {
  static constexpr float kInvalidScaleFactor = 0;
  base::ReadOnlySharedMemoryRegion invalid_emf_region;
  if (page_index >= total_page_count_) {
    std::move(callback).Run(std::move(invalid_emf_region), kInvalidScaleFactor);
    return;
  }

  float scale_factor = 1.0f;
  bool postscript =
      pdf_render_settings_.mode == PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2 ||
      pdf_render_settings_.mode == PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3 ||
      pdf_render_settings_.mode ==
          PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3_WITH_TYPE42_FONTS;
  base::ReadOnlySharedMemoryRegion emf_region =
      RenderPdfPageToMetafile(page_index, postscript, &scale_factor);
  std::move(callback).Run(std::move(emf_region), scale_factor);
}

void PdfToEmfConverter::SetWebContentsURL(const GURL& url) {
  // Record the most recent print job URL. This should be sufficient for common
  // Print Preview use cases.
  static crash_reporter::CrashKeyString<1024> crash_key("main-frame-url");
  crash_key.Set(url.spec());
}

void PdfToEmfConverter::SetUseSkiaRendererPolicy(bool use_skia) {
  chrome_pdf::SetUseSkiaRendererPolicy(use_skia);
}

}  // namespace printing