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

#include "pdf/pdfium/pdfium_form_filler.h"

#include <algorithm>
#include <memory>
#include <string>
#include <utility>

#include "base/auto_reset.h"
#include "base/check_op.h"
#include "base/containers/contains.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "pdf/pdf_features.h"
#include "pdf/pdfium/pdfium_engine.h"
#include "third_party/blink/public/common/input/web_input_event.h"
#include "third_party/pdfium/public/fpdf_annot.h"
#include "ui/base/window_open_disposition_utils.h"
#include "ui/gfx/geometry/rect.h"
#include "v8/include/v8-isolate.h"

namespace chrome_pdf {

namespace {

int g_last_timer_id = 0;

#if defined(PDF_ENABLE_V8)
std::string WideStringToString(FPDF_WIDESTRING wide_string) {
  return base::UTF16ToUTF8(reinterpret_cast<const char16_t*>(wide_string));
}
#endif

}  // namespace

// static
PDFiumFormFiller::ScriptOption PDFiumFormFiller::DefaultScriptOption() {
#if defined(PDF_ENABLE_XFA)
  if (base::FeatureList::IsEnabled(features::kPdfXfaSupport))
    return PDFiumFormFiller::ScriptOption::kJavaScriptAndXFA;
#endif  // defined(PDF_ENABLE_XFA)
  return PDFiumFormFiller::ScriptOption::kJavaScript;
}

PDFiumFormFiller::PDFiumFormFiller(PDFiumEngine* engine,
                                   ScriptOption script_option)
    : engine_in_isolate_scope_factory_(engine, script_option),
      script_option_(script_option) {
  // Initialize FPDF_FORMFILLINFO member variables.  Deriving from this struct
  // allows the static callbacks to be able to cast the FPDF_FORMFILLINFO in
  // callbacks to ourself instead of maintaining a map of them to
  // PDFiumEngine.
  FPDF_FORMFILLINFO::version = 2;
  FPDF_FORMFILLINFO::Release = nullptr;
  FPDF_FORMFILLINFO::FFI_Invalidate = Form_Invalidate;
  FPDF_FORMFILLINFO::FFI_OutputSelectedRect = Form_OutputSelectedRect;
  FPDF_FORMFILLINFO::FFI_SetCursor = Form_SetCursor;
  FPDF_FORMFILLINFO::FFI_SetTimer = Form_SetTimer;
  FPDF_FORMFILLINFO::FFI_KillTimer = Form_KillTimer;
  FPDF_FORMFILLINFO::FFI_GetLocalTime = Form_GetLocalTime;
  FPDF_FORMFILLINFO::FFI_OnChange = Form_OnChange;
  FPDF_FORMFILLINFO::FFI_GetPage = Form_GetPage;
  FPDF_FORMFILLINFO::FFI_GetCurrentPage = Form_GetCurrentPage;
  FPDF_FORMFILLINFO::FFI_GetRotation = Form_GetRotation;
  FPDF_FORMFILLINFO::FFI_ExecuteNamedAction = Form_ExecuteNamedAction;
  FPDF_FORMFILLINFO::FFI_SetTextFieldFocus = Form_SetTextFieldFocus;
  FPDF_FORMFILLINFO::FFI_DoURIAction = Form_DoURIAction;
  FPDF_FORMFILLINFO::FFI_DoGoToAction = Form_DoGoToAction;
  FPDF_FORMFILLINFO::FFI_OnFocusChange = Form_OnFocusChange;
  FPDF_FORMFILLINFO::FFI_DoURIActionWithKeyboardModifier =
      Form_DoURIActionWithKeyboardModifier;
  FPDF_FORMFILLINFO::xfa_disabled = true;
  FPDF_FORMFILLINFO::FFI_EmailTo = nullptr;
  FPDF_FORMFILLINFO::FFI_DisplayCaret = nullptr;
  FPDF_FORMFILLINFO::FFI_SetCurrentPage = nullptr;
  FPDF_FORMFILLINFO::FFI_GetCurrentPageIndex = nullptr;
  FPDF_FORMFILLINFO::FFI_GetPageViewRect = nullptr;
  FPDF_FORMFILLINFO::FFI_GetPlatform = nullptr;
  FPDF_FORMFILLINFO::FFI_PageEvent = nullptr;
  FPDF_FORMFILLINFO::FFI_PopupMenu = nullptr;
  FPDF_FORMFILLINFO::FFI_PostRequestURL = nullptr;
  FPDF_FORMFILLINFO::FFI_PutRequestURL = nullptr;
  FPDF_FORMFILLINFO::FFI_UploadTo = nullptr;
  FPDF_FORMFILLINFO::FFI_DownloadFromURL = nullptr;
  FPDF_FORMFILLINFO::FFI_OpenFile = nullptr;
  FPDF_FORMFILLINFO::FFI_GotoURL = nullptr;
  FPDF_FORMFILLINFO::FFI_GetLanguage = nullptr;
  FPDF_FORMFILLINFO::m_pJsPlatform = nullptr;

#if defined(PDF_ENABLE_V8)
  if (script_option != ScriptOption::kNoJavaScript) {
    FPDF_FORMFILLINFO::m_pJsPlatform = this;
    IPDF_JSPLATFORM::version = 3;
    IPDF_JSPLATFORM::app_alert = Form_Alert;
    IPDF_JSPLATFORM::app_beep = Form_Beep;
    IPDF_JSPLATFORM::app_response = Form_Response;
    IPDF_JSPLATFORM::Doc_getFilePath = Form_GetFilePath;
    IPDF_JSPLATFORM::Doc_mail = Form_Mail;
    IPDF_JSPLATFORM::Doc_print = Form_Print;
    IPDF_JSPLATFORM::Doc_submitForm = Form_SubmitForm;
    IPDF_JSPLATFORM::Doc_gotoPage = Form_GotoPage;
    IPDF_JSPLATFORM::Field_browse = nullptr;
  }
#if defined(PDF_ENABLE_XFA)
  if (script_option == ScriptOption::kJavaScriptAndXFA) {
    FPDF_FORMFILLINFO::xfa_disabled = false;
    FPDF_FORMFILLINFO::FFI_EmailTo = Form_EmailTo;
    FPDF_FORMFILLINFO::FFI_DisplayCaret = Form_DisplayCaret;
    FPDF_FORMFILLINFO::FFI_SetCurrentPage = Form_SetCurrentPage;
    FPDF_FORMFILLINFO::FFI_GetCurrentPageIndex = Form_GetCurrentPageIndex;
    FPDF_FORMFILLINFO::FFI_GetPageViewRect = Form_GetPageViewRect;
    FPDF_FORMFILLINFO::FFI_GetPlatform = Form_GetPlatform;
    FPDF_FORMFILLINFO::FFI_PageEvent = Form_PageEvent;
    FPDF_FORMFILLINFO::FFI_PopupMenu = Form_PopupMenu;
    FPDF_FORMFILLINFO::FFI_PostRequestURL = Form_PostRequestURL;
    FPDF_FORMFILLINFO::FFI_PutRequestURL = Form_PutRequestURL;
    FPDF_FORMFILLINFO::FFI_UploadTo = Form_UploadTo;
    FPDF_FORMFILLINFO::FFI_DownloadFromURL = Form_DownloadFromURL;
    FPDF_FORMFILLINFO::FFI_OpenFile = Form_OpenFile;
    FPDF_FORMFILLINFO::FFI_GotoURL = Form_GotoURL;
    FPDF_FORMFILLINFO::FFI_GetLanguage = Form_GetLanguage;
  }
#endif  // defined(PDF_ENABLE_XFA)
#endif  // defined(PDF_ENABLE_V8)
}

PDFiumFormFiller::~PDFiumFormFiller() = default;

// static
void PDFiumFormFiller::Form_Invalidate(FPDF_FORMFILLINFO* param,
                                       FPDF_PAGE page,
                                       double left,
                                       double top,
                                       double right,
                                       double bottom) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  int page_index = engine->GetVisiblePageIndex(page);
  if (page_index == -1) {
    // This can sometime happen when the page is closed because it went off
    // screen, and PDFium invalidates the control as it's being deleted.
    return;
  }

  gfx::Rect rect = engine->pages_[page_index]->PageToScreen(
      engine->GetVisibleRect().origin(), engine->current_zoom_, left, top,
      right, bottom, engine->layout_.options().default_page_orientation());
  engine->client_->Invalidate(rect);
}

// static
void PDFiumFormFiller::Form_OutputSelectedRect(FPDF_FORMFILLINFO* param,
                                               FPDF_PAGE page,
                                               double left,
                                               double top,
                                               double right,
                                               double bottom) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  int page_index = engine->GetVisiblePageIndex(page);
  if (page_index == -1)
    return;

  gfx::Rect rect = engine->pages_[page_index]->PageToScreen(
      engine->GetVisibleRect().origin(), engine->current_zoom_, left, top,
      right, bottom, engine->layout_.options().default_page_orientation());
  if (rect.IsEmpty())
    return;

  engine->form_highlights_.push_back(rect);
}

// static
void PDFiumFormFiller::Form_SetCursor(FPDF_FORMFILLINFO* param,
                                      int cursor_type) {
  // We don't need this since it's not enough to change the cursor in all
  // scenarios.  Instead, we check which form field we're under in OnMouseMove.
}

// static
int PDFiumFormFiller::Form_SetTimer(FPDF_FORMFILLINFO* param,
                                    int elapse,
                                    TimerCallback timer_func) {
  auto* form_filler = static_cast<PDFiumFormFiller*>(param);
  return form_filler->SetTimer(base::Milliseconds(elapse), timer_func);
}

// static
void PDFiumFormFiller::Form_KillTimer(FPDF_FORMFILLINFO* param, int timer_id) {
  auto* form_filler = static_cast<PDFiumFormFiller*>(param);
  form_filler->KillTimer(timer_id);
}

// static
FPDF_SYSTEMTIME PDFiumFormFiller::Form_GetLocalTime(FPDF_FORMFILLINFO* param) {
  base::Time time = base::Time::Now();
  base::Time::Exploded exploded;
  time.LocalExplode(&exploded);
  return FPDF_SYSTEMTIME{
      .wYear = static_cast<unsigned short>(exploded.year),
      .wMonth = static_cast<unsigned short>(exploded.month),
      .wDayOfWeek = static_cast<unsigned short>(exploded.day_of_week),
      .wDay = static_cast<unsigned short>(exploded.day_of_month),
      .wHour = static_cast<unsigned short>(exploded.hour),
      .wMinute = static_cast<unsigned short>(exploded.minute),
      .wSecond = static_cast<unsigned short>(exploded.second),
      .wMilliseconds = static_cast<unsigned short>(exploded.millisecond)};
}

// static
void PDFiumFormFiller::Form_OnChange(FPDF_FORMFILLINFO* param) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->EnteredEditMode();
}

// static
FPDF_PAGE PDFiumFormFiller::Form_GetPage(FPDF_FORMFILLINFO* param,
                                         FPDF_DOCUMENT document,
                                         int page_index) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  if (!engine->PageIndexInBounds(page_index))
    return nullptr;
  return engine->pages_[page_index]->GetPage();
}

// static
FPDF_PAGE PDFiumFormFiller::Form_GetCurrentPage(FPDF_FORMFILLINFO* param,
                                                FPDF_DOCUMENT document) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  int index = engine->last_focused_page_;
  if (index == -1) {
    index = engine->GetMostVisiblePage();
    if (index == -1)
      return nullptr;
  }

  DCHECK_NE(index, -1);
  return engine->pages_[index]->GetPage();
}

// static
int PDFiumFormFiller::Form_GetRotation(FPDF_FORMFILLINFO* param,
                                       FPDF_PAGE page) {
  return 0;
}

// static
void PDFiumFormFiller::Form_ExecuteNamedAction(FPDF_FORMFILLINFO* param,
                                               FPDF_BYTESTRING named_action) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  std::string action(named_action);
  if (action == "Print") {
    engine->client_->Print();
    return;
  }

  int index = engine->last_focused_page_;
  /* Don't try to calculate the most visible page if we don't have a left click
     before this event (this code originally copied Form_GetCurrentPage which of
     course needs to do that and which doesn't have recursion). This can end up
     causing infinite recursion. See http://crbug.com/240413 for more
     information. Either way, it's not necessary for the spec'd list of named
     actions.
  if (index == -1)
    index = engine->GetMostVisiblePage();
  */
  if (index == -1)
    return;

  // This is the only list of named actions per the spec (see 12.6.4.11). Adobe
  // Reader supports more, like FitWidth, but since they're not part of the spec
  // and we haven't got bugs about them, no need to now.
  if (action == "NextPage") {
    engine->ScrollToPage(index + 1);
  } else if (action == "PrevPage") {
    engine->ScrollToPage(index - 1);
  } else if (action == "FirstPage") {
    engine->ScrollToPage(0);
  } else if (action == "LastPage") {
    engine->ScrollToPage(engine->pages_.size() - 1);
  }
}

// static
void PDFiumFormFiller::Form_SetTextFieldFocus(FPDF_FORMFILLINFO* param,
                                              FPDF_WIDESTRING value,
                                              FPDF_DWORD valueLen,
                                              FPDF_BOOL is_focus) {
  // Do nothing for now.
  // TODO(gene): use this signal to trigger OSK.
}

// static
void PDFiumFormFiller::Form_OnFocusChange(FPDF_FORMFILLINFO* param,
                                          FPDF_ANNOTATION annot,
                                          int page_index) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  if (!engine->PageIndexInBounds(page_index))
    return;

  base::AutoReset<bool> defer_page_unload_guard(&engine->defer_page_unload_,
                                                true);

  // Maintain viewport if we are updating focus. This is to ensure that we don't
  // scroll the focused annotation into view when focus is regained.
  if (!engine->updating_focus_)
    engine->ScrollAnnotationIntoView(annot, page_index);

  engine->OnFocusedAnnotationUpdated(annot, page_index);
}

// static
void PDFiumFormFiller::Form_DoURIAction(FPDF_FORMFILLINFO* param,
                                        FPDF_BYTESTRING uri) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->client_->NavigateTo(std::string(uri),
                              WindowOpenDisposition::CURRENT_TAB);
}

// static
void PDFiumFormFiller::Form_DoGoToAction(FPDF_FORMFILLINFO* param,
                                         int page_index,
                                         int zoom_mode,
                                         float* position_array,
                                         int size_of_array) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->ScrollToPage(page_index);
}

// static
void PDFiumFormFiller::Form_DoURIActionWithKeyboardModifier(
    FPDF_FORMFILLINFO* param,
    FPDF_BYTESTRING uri,
    int modifiers) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  bool middle_button =
      !!(modifiers & blink::WebInputEvent::Modifiers::kMiddleButtonDown);
  bool alt_key = !!(modifiers & blink::WebInputEvent::Modifiers::kAltKey);
  bool ctrl_key = !!(modifiers & blink::WebInputEvent::Modifiers::kControlKey);
  bool meta_key = !!(modifiers & blink::WebInputEvent::Modifiers::kMetaKey);
  bool shift_key = !!(modifiers & blink::WebInputEvent::Modifiers::kShiftKey);

  WindowOpenDisposition disposition = ui::DispositionFromClick(
      middle_button, alt_key, ctrl_key, meta_key, shift_key);

  engine->client_->NavigateTo(std::string(uri), disposition);
}

#if defined(PDF_ENABLE_V8)
#if defined(PDF_ENABLE_XFA)

// static
void PDFiumFormFiller::Form_EmailTo(FPDF_FORMFILLINFO* param,
                                    FPDF_FILEHANDLER* file_handler,
                                    FPDF_WIDESTRING to,
                                    FPDF_WIDESTRING subject,
                                    FPDF_WIDESTRING cc,
                                    FPDF_WIDESTRING bcc,
                                    FPDF_WIDESTRING message) {
  std::string to_str = WideStringToString(to);
  std::string subject_str = WideStringToString(subject);
  std::string cc_str = WideStringToString(cc);
  std::string bcc_str = WideStringToString(bcc);
  std::string message_str = WideStringToString(message);

  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->client_->Email(to_str, cc_str, bcc_str, subject_str, message_str);
}

// static
void PDFiumFormFiller::Form_DisplayCaret(FPDF_FORMFILLINFO* param,
                                         FPDF_PAGE page,
                                         FPDF_BOOL visible,
                                         double left,
                                         double top,
                                         double right,
                                         double bottom) {}

// static
void PDFiumFormFiller::Form_SetCurrentPage(FPDF_FORMFILLINFO* param,
                                           FPDF_DOCUMENT document,
                                           int page) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->ScrollToPage(page);
}

// static
int PDFiumFormFiller::Form_GetCurrentPageIndex(FPDF_FORMFILLINFO* param,
                                               FPDF_DOCUMENT document) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  return engine->GetMostVisiblePage();
}

// static
void PDFiumFormFiller::Form_GetPageViewRect(FPDF_FORMFILLINFO* param,
                                            FPDF_PAGE page,
                                            double* left,
                                            double* top,
                                            double* right,
                                            double* bottom) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  int page_index = engine->GetVisiblePageIndex(page);
  if (!engine->PageIndexInBounds(page_index)) {
    *left = 0;
    *right = 0;
    *top = 0;
    *bottom = 0;
    return;
  }

  gfx::Rect page_view_rect = engine->GetPageContentsRect(page_index);

  float page_width = FPDF_GetPageWidth(page);
  float page_height = FPDF_GetPageHeight(page);

  // To convert from a screen scale to a page scale, we multiply by
  // (page_height / page_view_rect.height()) and
  // (page_width / page_view_rect.width()),
  // The base point of the page in screen coords is (page_view_rect.x(),
  // page_view_rect.y()).
  // Therefore, to convert an x position from screen to page
  // coords, we use (page_width * (x - base_x) / page_view_rect.width()).
  // For y positions, (page_height * (y - base_y) / page_view_rect.height()).

  // The top-most x position that is visible on the screen is the top of the
  // plugin area, which is y = 0.
  float screen_top_in_page_coords =
      page_height * (0 - page_view_rect.y()) / page_view_rect.height();
  // The bottom-most y position that is visible on the screen is the bottom of
  // the plugin area, which is y = engine->plugin_size().height().
  float screen_bottom_in_page_coords =
      page_height * (engine->plugin_size().height() - page_view_rect.y()) /
      page_view_rect.height();
  // The left-most x position that is visible on the screen is the left of the
  // plugin area, which is x = 0.
  float screen_left_in_page_coords =
      page_width * (0 - page_view_rect.x()) / page_view_rect.width();
  // The right-most x position that is visible on the screen is the right of the
  // plugin area, which is x = engine->plugin_size().width().
  float screen_right_in_page_coords =
      page_width * (engine->plugin_size().width() - page_view_rect.x()) /
      page_view_rect.width();

  // Return the edge of the screen or of the page, since we're restricted to
  // both.
  *left = std::max(screen_left_in_page_coords, 0.0f);
  *right = std::min(screen_right_in_page_coords, page_width);
  *top = std::max(screen_top_in_page_coords, 0.0f);
  *bottom = std::min(screen_bottom_in_page_coords, page_height);
}

// static
int PDFiumFormFiller::Form_GetPlatform(FPDF_FORMFILLINFO* param,
                                       void* platform,
                                       int length) {
  int platform_flag = -1;

#if defined(WIN32)
  platform_flag = 0;
#elif defined(__linux__)
  platform_flag = 1;
#else
  platform_flag = 2;
#endif

  std::string javascript =
      "alert(\"Platform:" + base::NumberToString(platform_flag) + "\")";

  return platform_flag;
}

// static
void PDFiumFormFiller::Form_PageEvent(FPDF_FORMFILLINFO* param,
                                      int page_count,
                                      unsigned long event_type) {
  DCHECK(page_count != 0);
  DCHECK(event_type == FXFA_PAGEVIEWEVENT_POSTADDED ||
         event_type == FXFA_PAGEVIEWEVENT_POSTREMOVED);

  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->UpdatePageCount();
}

// static
FPDF_BOOL PDFiumFormFiller::Form_PopupMenu(FPDF_FORMFILLINFO* param,
                                           FPDF_PAGE page,
                                           FPDF_WIDGET widget,
                                           int menu_flag,
                                           float x,
                                           float y) {
  return false;
}

// static
FPDF_BOOL PDFiumFormFiller::Form_PostRequestURL(FPDF_FORMFILLINFO* param,
                                                FPDF_WIDESTRING url,
                                                FPDF_WIDESTRING data,
                                                FPDF_WIDESTRING content_type,
                                                FPDF_WIDESTRING encode,
                                                FPDF_WIDESTRING header,
                                                FPDF_BSTR* response) {
  // NOTE: Think hard about the privacy implications before allowing
  // a PDF file to perform this action, as it might be used for beaconing.
  return true;
}

// static
FPDF_BOOL PDFiumFormFiller::Form_PutRequestURL(FPDF_FORMFILLINFO* param,
                                               FPDF_WIDESTRING url,
                                               FPDF_WIDESTRING data,
                                               FPDF_WIDESTRING encode) {
  // NOTE: Think hard about the privacy implications before allowing
  // a PDF file to perform this action, as it might be used for beaconing.
  return true;
}

// static
void PDFiumFormFiller::Form_UploadTo(FPDF_FORMFILLINFO* param,
                                     FPDF_FILEHANDLER* file_handle,
                                     int file_flag,
                                     FPDF_WIDESTRING to) {
  // NOTE: Think hard about the privacy implications before allowing
  // a PDF file to perform this action, as it might be used for beaconing.
}

// static
FPDF_FILEHANDLER* PDFiumFormFiller::Form_DownloadFromURL(
    FPDF_FORMFILLINFO* param,
    FPDF_WIDESTRING url) {
  // NOTE: Think hard about the security implications before allowing
  // a PDF file to perform this action. Also think hard about the privacy
  // implications, as it might be used for beaconing.
  return nullptr;
}

// static
FPDF_FILEHANDLER* PDFiumFormFiller::Form_OpenFile(FPDF_FORMFILLINFO* param,
                                                  int file_flag,
                                                  FPDF_WIDESTRING url,
                                                  const char* mode) {
  // NOTE: Think hard about the security implications before allowing
  // a PDF file to perform this action.
  return nullptr;
}

// static
void PDFiumFormFiller::Form_GotoURL(FPDF_FORMFILLINFO* param,
                                    FPDF_DOCUMENT document,
                                    FPDF_WIDESTRING url) {
  // NOTE: Think hard about the security implications before allowing
  // a PDF file to perform this action. Also think hard about the privacy
  // implications, as it might be used for beaconing.
}

// static
int PDFiumFormFiller::Form_GetLanguage(FPDF_FORMFILLINFO* param,
                                       void* language,
                                       int length) {
  return 0;
}

#endif  // defined(PDF_ENABLE_XFA)

// static
int PDFiumFormFiller::Form_Alert(IPDF_JSPLATFORM* param,
                                 FPDF_WIDESTRING message,
                                 FPDF_WIDESTRING title,
                                 int type,
                                 int icon) {
  // See fpdfformfill.h for these values.
  enum AlertType {
    ALERT_TYPE_OK = 0,
    ALERT_TYPE_OK_CANCEL,
    ALERT_TYPE_YES_ON,
    ALERT_TYPE_YES_NO_CANCEL
  };

  enum AlertResult {
    ALERT_RESULT_OK = 1,
    ALERT_RESULT_CANCEL,
    ALERT_RESULT_NO,
    ALERT_RESULT_YES
  };

  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  std::string message_str = WideStringToString(message);
  if (type == ALERT_TYPE_OK) {
    engine->client_->Alert(message_str);
    return ALERT_RESULT_OK;
  }

  bool rv = engine->client_->Confirm(message_str);
  if (type == ALERT_TYPE_OK_CANCEL)
    return rv ? ALERT_RESULT_OK : ALERT_RESULT_CANCEL;
  return rv ? ALERT_RESULT_YES : ALERT_RESULT_NO;
}

// static
void PDFiumFormFiller::Form_Beep(IPDF_JSPLATFORM* param, int type) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->client_->Beep();
}

// static
int PDFiumFormFiller::Form_Response(IPDF_JSPLATFORM* param,
                                    FPDF_WIDESTRING question,
                                    FPDF_WIDESTRING title,
                                    FPDF_WIDESTRING default_response,
                                    FPDF_WIDESTRING label,
                                    FPDF_BOOL password,
                                    void* response,
                                    int length) {
  std::string question_str = WideStringToString(question);
  std::string default_str = WideStringToString(default_response);

  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  std::string rv = engine->client_->Prompt(question_str, default_str);
  std::u16string rv_16 = base::UTF8ToUTF16(rv);
  int rv_bytes = rv_16.size() * sizeof(char16_t);
  if (response) {
    int bytes_to_copy = rv_bytes < length ? rv_bytes : length;
    memcpy(response, rv_16.c_str(), bytes_to_copy);
  }
  return rv_bytes;
}

// static
int PDFiumFormFiller::Form_GetFilePath(IPDF_JSPLATFORM* param,
                                       void* file_path,
                                       int length) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  std::string rv = engine->client_->GetURL();

  // Account for the trailing null.
  int necessary_length = rv.size() + 1;
  if (file_path && necessary_length <= length)
    memcpy(file_path, rv.c_str(), necessary_length);
  return necessary_length;
}

// static
void PDFiumFormFiller::Form_Mail(IPDF_JSPLATFORM* param,
                                 void* mail_data,
                                 int length,
                                 FPDF_BOOL ui,
                                 FPDF_WIDESTRING to,
                                 FPDF_WIDESTRING subject,
                                 FPDF_WIDESTRING cc,
                                 FPDF_WIDESTRING bcc,
                                 FPDF_WIDESTRING message) {
  // Note: `mail_data` and `length` are ignored. We don't handle attachments;
  // there is no way with mailto.
  std::string to_str = WideStringToString(to);
  std::string cc_str = WideStringToString(cc);
  std::string bcc_str = WideStringToString(bcc);
  std::string subject_str = WideStringToString(subject);
  std::string message_str = WideStringToString(message);

  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->client_->Email(to_str, cc_str, bcc_str, subject_str, message_str);
}

// static
void PDFiumFormFiller::Form_Print(IPDF_JSPLATFORM* param,
                                  FPDF_BOOL ui,
                                  int start,
                                  int end,
                                  FPDF_BOOL silent,
                                  FPDF_BOOL shrink_to_fit,
                                  FPDF_BOOL print_as_image,
                                  FPDF_BOOL reverse,
                                  FPDF_BOOL annotations) {
  // No way to pass the extra information to the print dialog using JavaScript.
  // Just opening it is fine for now.
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->client_->Print();
}

// static
void PDFiumFormFiller::Form_SubmitForm(IPDF_JSPLATFORM* param,
                                       void* form_data,
                                       int length,
                                       FPDF_WIDESTRING url) {
  std::string url_str = WideStringToString(url);
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->client_->SubmitForm(url_str, form_data, length);
}

// static
void PDFiumFormFiller::Form_GotoPage(IPDF_JSPLATFORM* param, int page_number) {
  EngineInIsolateScope engine_scope = GetEngineInIsolateScope(param);
  PDFiumEngine* engine = engine_scope.engine();
  engine->ScrollToPage(page_number);
}

#endif  // defined(PDF_ENABLE_V8)

PDFiumFormFiller::EngineInIsolateScope::EngineInIsolateScope(
    PDFiumEngine* engine,
    v8::Isolate* isolate)
    : isolate_scope_(isolate ? std::make_unique<v8::Isolate::Scope>(isolate)
                             : nullptr),
      engine_(engine) {
  DCHECK(engine_);
}

PDFiumFormFiller::EngineInIsolateScope::EngineInIsolateScope(
    EngineInIsolateScope&&) = default;

PDFiumFormFiller::EngineInIsolateScope&
PDFiumFormFiller::EngineInIsolateScope::operator=(EngineInIsolateScope&&) =
    default;

PDFiumFormFiller::EngineInIsolateScope::~EngineInIsolateScope() = default;

PDFiumFormFiller::EngineInIsolateScopeFactory::EngineInIsolateScopeFactory(
    PDFiumEngine* engine,
    ScriptOption script_option)
    : engine_(engine),
      callback_isolate_(script_option !=
                                PDFiumFormFiller::ScriptOption::kNoJavaScript
                            ? v8::Isolate::TryGetCurrent()
                            : nullptr) {
  if (callback_isolate_) {
    CHECK_EQ(engine_->client_->GetIsolate(), callback_isolate_);
  }
}

PDFiumFormFiller::EngineInIsolateScopeFactory::~EngineInIsolateScopeFactory() =
    default;

PDFiumFormFiller::EngineInIsolateScope
PDFiumFormFiller::EngineInIsolateScopeFactory::GetEngineInIsolateScope() const {
  return EngineInIsolateScope(engine_, callback_isolate_);
}

// static
PDFiumFormFiller::EngineInIsolateScope
PDFiumFormFiller::GetEngineInIsolateScope(FPDF_FORMFILLINFO* info) {
  auto* form_filler = static_cast<PDFiumFormFiller*>(info);
  return form_filler->engine_in_isolate_scope_factory_
      .GetEngineInIsolateScope();
}

// static
PDFiumFormFiller::EngineInIsolateScope
PDFiumFormFiller::GetEngineInIsolateScope(IPDF_JSPLATFORM* platform) {
  auto* form_filler = static_cast<PDFiumFormFiller*>(platform);
  return form_filler->engine_in_isolate_scope_factory_
      .GetEngineInIsolateScope();
}

int PDFiumFormFiller::SetTimer(const base::TimeDelta& delay,
                               TimerCallback timer_func) {
  const int timer_id = ++g_last_timer_id;
  DCHECK(!base::Contains(timers_, timer_id));

  auto timer = std::make_unique<base::RepeatingTimer>();
  timer->Start(FROM_HERE, delay, base::BindRepeating(timer_func, timer_id));
  timers_[timer_id] = std::move(timer);
  return timer_id;
}

void PDFiumFormFiller::KillTimer(int timer_id) {
  size_t erased = timers_.erase(timer_id);
  DCHECK_EQ(1u, erased);
}

}  // namespace chrome_pdf