<?php

declare(strict_types=1);

namespace Drupal\Tests\media_library\FunctionalJavascript;

use Behat\Mink\Element\NodeElement;
use Drupal\FunctionalJavascriptTests\WebDriverTestBase;
use Drupal\media\Entity\Media;

/**
 * Base class for functional tests of Media Library functionality.
 */
abstract class MediaLibraryTestBase extends WebDriverTestBase {

  /**
   * {@inheritdoc}
   */
  protected static $modules = ['media_library_test', 'hold_test'];

  /**
   * {@inheritdoc}
   */
  protected $defaultTheme = 'stark';

  /**
   * Create media items.
   *
   * @param array $media_items
   *   A nested array of media item names keyed by media type.
   *
   * @return \Drupal\media\MediaInterface[]
   *   An array of media entities keyed by the names passed in.
   */
  protected function createMediaItems(array $media_items) {
    $created_items = [];
    $time = time();
    foreach ($media_items as $type => $names) {
      foreach ($names as $name) {
        /** @var \Drupal\media\MediaInterface $media */
        $media = Media::create([
          'name' => $name,
          'bundle' => $type,
        ]);
        $source_field = $media->getSource()
          ->getSourceFieldDefinition($media->bundle->entity)
          ->getName();
        $media->set($source_field, $name)->setCreatedTime(++$time)->save();
        $created_items[$name] = $media;
      }
    }
    return $created_items;
  }

  /**
   * Asserts that text appears on page after a wait.
   *
   * @param string $text
   *   The text that should appear on the page.
   * @param int $timeout
   *   Timeout in milliseconds, defaults to 10000.
   *
   * @todo replace with whatever gets added in
   *   https://www.drupal.org/node/3061852
   */
  protected function waitForText($text, $timeout = 10000) {
    $result = $this->assertSession()->waitForText($text, $timeout);
    $this->assertNotEmpty($result, "\"$text\" not found");
  }

  /**
   * Asserts that text does not appear on page after a wait.
   *
   * @param string $text
   *   The text that should not be on the page.
   * @param int $timeout
   *   Timeout in milliseconds, defaults to 10000.
   *
   * @todo replace with whatever gets added in
   *   https://www.drupal.org/node/3061852
   */
  protected function waitForNoText($text, $timeout = 10000) {
    $page = $this->getSession()->getPage();
    $result = $page->waitFor($timeout / 1000, function ($page) use ($text) {
      $actual = preg_replace('/\s+/u', ' ', $page->getText());
      $regex = '/' . preg_quote($text, '/') . '/ui';
      return (bool) !preg_match($regex, $actual);
    });
    $this->assertNotEmpty($result, "\"$text\" was found but shouldn't be there.");
  }

  /**
   * Checks for a specified number of specific elements on page after wait.
   *
   * @param string $selector_type
   *   Element selector type (css, xpath)
   * @param string|array $selector
   *   Element selector.
   * @param int $count
   *   Expected count.
   * @param int $timeout
   *   Timeout in milliseconds, defaults to 10000.
   *
   * @todo replace with whatever gets added in
   *   https://www.drupal.org/node/3061852
   */
  protected function waitForElementsCount($selector_type, $selector, $count, $timeout = 10000) {
    $page = $this->getSession()->getPage();

    $start = microtime(TRUE);
    $end = $start + ($timeout / 1000);
    do {
      $nodes = $page->findAll($selector_type, $selector);
      if (count($nodes) === $count) {
        return;
      }
      usleep(100000);
    } while (microtime(TRUE) < $end);

    $this->assertSession()->elementsCount($selector_type, $selector, $count);
  }

  /**
   * Asserts that text appears in an element after a wait.
   *
   * @param string $selector
   *   The CSS selector of the element to check.
   * @param string $text
   *   The text that should appear in the element.
   * @param int $timeout
   *   Timeout in milliseconds, defaults to 10000.
   *
   * @todo replace with whatever gets added in
   *   https://www.drupal.org/node/3061852
   */
  protected function waitForElementTextContains($selector, $text, $timeout = 10000) {
    $element = $this->assertSession()->waitForElement('css', "$selector:contains('$text')", $timeout);
    $this->assertNotEmpty($element);
  }

  /**
   * Waits for the specified selector and returns it if not empty.
   *
   * @param string $selector
   *   The selector engine name. See ElementInterface::findAll() for the
   *   supported selectors.
   * @param string|array $locator
   *   The selector locator.
   * @param int $timeout
   *   Timeout in milliseconds, defaults to 10000.
   *
   * @return \Behat\Mink\Element\NodeElement
   *   The page element node if found. If not found, the test fails.
   *
   * @todo replace with whatever gets added in
   *   https://www.drupal.org/node/3061852
   */
  protected function assertElementExistsAfterWait($selector, $locator, $timeout = 10000): NodeElement {
    $element = $this->assertSession()->waitForElement($selector, $locator, $timeout);
    $this->assertNotEmpty($element);
    return $element;
  }

  /**
   * Gets the menu of available media types.
   *
   * @return \Behat\Mink\Element\NodeElement
   *   The menu of available media types.
   */
  protected function getTypesMenu(): NodeElement {
    return $this->assertSession()
      ->elementExists('css', '.js-media-library-menu');
  }

  /**
   * Clicks a media type tab and waits for it to appear.
   */
  protected function switchToMediaType($type) {
    $link = $this->assertSession()
      ->elementExists('named', ['link', "Type $type"], $this->getTypesMenu());

    if ($link->hasClass('active')) {
      // There is nothing to do as the type is already active.
      return;
    }

    $link->click();
    $result = $link->waitFor(10, function ($link) {
      /** @var \Behat\Mink\Element\NodeElement $link */
      return $link->hasClass('active');
    });
    $this->assertNotEmpty($result);

    // assertWaitOnAjaxRequest() required for input "id" attributes to
    // consistently match their label's "for" attribute.
    $this->assertSession()->assertWaitOnAjaxRequest();
  }

  /**
   * Checks for the existence of a field on page after wait.
   *
   * @param string $field
   *   The field to find.
   * @param int $timeout
   *   Timeout in milliseconds, defaults to 10000.
   *
   * @return \Behat\Mink\Element\NodeElement|null
   *   The element if found, otherwise null.
   *
   * @todo replace with whatever gets added in
   *   https://www.drupal.org/node/3061852
   */
  protected function waitForFieldExists($field, $timeout = 10000) {
    $assert_session = $this->assertSession();
    $assert_session->waitForField($field, $timeout);
    return $assert_session->fieldExists($field);
  }

  /**
   * Waits for a file field to exist before uploading.
   */
  public function addMediaFileToField($locator, $path) {
    $page = $this->getSession()->getPage();
    $this->waitForFieldExists($locator);
    $page->attachFileToField($locator, $path);
  }

  /**
   * Clicks "Save and select||insert" button and waits for AJAX completion.
   *
   * @param string $operation
   *   The final word of the button to be clicked.
   */
  protected function saveAnd($operation) {
    $this->assertElementExistsAfterWait('css', '.ui-dialog-buttonpane')->pressButton("Save and $operation");

    // assertWaitOnAjaxRequest() required for input "id" attributes to
    // consistently match their label's "for" attribute.
    $this->assertSession()->assertWaitOnAjaxRequest();
  }

  /**
   * Clicks "Save" button and waits for AJAX completion.
   *
   * @param bool $expect_errors
   *   Whether validation errors are expected after the "Save" button is
   *   pressed. Defaults to FALSE.
   */
  protected function pressSaveButton($expect_errors = FALSE) {
    $buttons = $this->assertElementExistsAfterWait('css', '.ui-dialog-buttonpane');
    $buttons->pressButton('Save');

    // If no validation errors are expected, wait for the "Insert selected"
    // button to return.
    if (!$expect_errors) {
      $result = $buttons->waitFor(10, function ($buttons) {
        /** @var \Behat\Mink\Element\NodeElement $buttons */
        return $buttons->findButton('Insert selected');
      });
      $this->assertNotEmpty($result);
    }

    // assertWaitOnAjaxRequest() required for input "id" attributes to
    // consistently match their label's "for" attribute.
    $this->assertSession()->assertWaitOnAjaxRequest();
  }

  /**
   * Clicks a button that opens a media widget and confirms it is open.
   *
   * @param string $field_name
   *   The machine name of the field for which to open the media library.
   * @param string $after_open_selector
   *   The selector to look for after the button is clicked.
   *
   * @return \Behat\Mink\Element\NodeElement
   *   The NodeElement found via $after_open_selector.
   */
  protected function openMediaLibraryForField($field_name, $after_open_selector = '.js-media-library-menu'): NodeElement {
    $this->assertElementExistsAfterWait('css', "#$field_name-media-library-wrapper.js-media-library-widget")
      ->pressButton('Add media');
    $this->waitForText('Add or select media');

    // Assert that the grid display is visible and the links to toggle between
    // the grid and table displays are present.
    $this->assertMediaLibraryGrid();
    $assert_session = $this->assertSession();
    $assert_session->linkExists('Grid');
    $assert_session->linkExists('Table');

    // The "select all" checkbox should never be present in the modal.
    $assert_session->elementNotExists('css', '.media-library-select-all');

    return $this->assertElementExistsAfterWait('css', $after_open_selector);
  }

  /**
   * Gets the "Additional selected media" area after adding new media.
   *
   * @param bool $open
   *   Whether or not to open the area before returning it. Defaults to TRUE.
   *
   * @return \Behat\Mink\Element\NodeElement
   *   The "additional selected media" area.
   */
  protected function getSelectionArea($open = TRUE): NodeElement {
    $summary = $this->assertElementExistsAfterWait('css', 'summary:contains("Additional selected media")');
    if ($open) {
      $summary->click();
    }
    return $summary->getParent();
  }

  /**
   * Asserts a media item was added, but not yet saved.
   *
   * @param int $index
   *   (optional) The index of the media item, if multiple items can be added at
   *   once. Defaults to 0.
   */
  protected function assertMediaAdded($index = 0) {
    $selector = '.js-media-library-add-form-added-media';

    // Assert that focus is shifted to the new media items.
    $this->assertJsCondition('jQuery("' . $selector . '").is(":focus")');

    $assert_session = $this->assertSession();
    $assert_session->pageTextMatches('/The media items? ha(s|ve) been created but ha(s|ve) not yet been saved. Fill in any required fields and save to add (it|them) to the media library./');
    $assert_session->elementAttributeContains('css', $selector, 'aria-label', 'Added media items');

    $fields = $this->assertElementExistsAfterWait('css', '[data-drupal-selector="edit-media-' . $index . '-fields"]');
    $assert_session->elementNotExists('css', '.js-media-library-menu');

    // Assert extraneous components were removed in
    // FileUploadForm::hideExtraSourceFieldComponents().
    $assert_session->elementNotExists('css', '[data-drupal-selector$="preview"]', $fields);
    $assert_session->buttonNotExists('Remove', $fields);
    $assert_session->elementNotExists('css', '[data-drupal-selector$="filename"]', $fields);
  }

  /**
   * Asserts that media was not added, i.e. due to a validation error.
   */
  protected function assertNoMediaAdded() {
    // Assert the focus is shifted to the first tabbable element of the add
    // form, which should be the source field.
    $this->assertJsCondition('jQuery(tabbable.tabbable(document.getElementById("media-library-add-form-wrapper"))[0]).is(":focus")');

    $this->assertSession()
      ->elementNotExists('css', '[data-drupal-selector="edit-media-0-fields"]');
    $this->getTypesMenu();
  }

  /**
   * Presses the modal's "Insert selected" button.
   *
   * @param string $expected_announcement
   *   (optional) The expected screen reader announcement once the modal is
   *   closed.
   * @param bool $should_close
   *   (optional) TRUE if we expect the modal to be successfully closed.
   *
   * @todo Consider requiring screen reader assertion every time "Insert
   *   selected" is pressed in
   *   https://www.drupal.org/project/drupal/issues/3087227.
   */
  protected function pressInsertSelected($expected_announcement = NULL, bool $should_close = TRUE) {
    $this->assertSession()
      ->elementExists('css', '.ui-dialog-buttonpane')
      ->pressButton('Insert selected');

    if ($should_close) {
      $this->waitForNoText('Add or select media');
    }
    if ($expected_announcement) {
      $this->waitForText($expected_announcement);
    }
  }

  /**
   * Gets all available media item checkboxes.
   *
   * @return \Behat\Mink\Element\NodeElement[]
   *   The available checkboxes.
   */
  protected function getCheckboxes() {
    return $this->getSession()
      ->getPage()
      ->findAll('css', '.js-media-library-view .js-click-to-select-checkbox input');
  }

  /**
   * Selects an item in the media library modal.
   *
   * @param int $index
   *   The zero-based index of the item to select.
   * @param string $expected_selected_count
   *   (optional) The expected text of the selection counter.
   */
  protected function selectMediaItem($index, $expected_selected_count = NULL) {
    $checkboxes = $this->getCheckboxes();
    $this->assertGreaterThan($index, count($checkboxes));
    $checkboxes[$index]->check();

    if ($expected_selected_count) {
      $this->assertSelectedMediaCount($expected_selected_count);
    }
  }

  /**
   * De-selects an item in the media library modal.
   *
   * @param int $index
   *   The zero-based index of the item to unselect.
   */
  protected function deselectMediaItem(int $index): void {
    $checkboxes = $this->getCheckboxes();
    $this->assertGreaterThan($index, count($checkboxes));
    $checkboxes[$index]->uncheck();
  }

  /**
   * Switches to the grid display of the widget view.
   */
  protected function switchToMediaLibraryGrid() {
    $this->getSession()->getPage()->clickLink('Grid');
    // Assert the display change is correctly announced for screen readers.
    $this->assertAnnounceContains('Loading grid view.');
    $this->assertAnnounceContains('Changed to grid view.');
    $this->assertMediaLibraryGrid();
  }

  /**
   * Switches to the table display of the widget view.
   */
  protected function switchToMediaLibraryTable() {
    hold_test_response(TRUE);
    $this->getSession()->getPage()->clickLink('Table');
    // Assert the display change is correctly announced for screen readers.
    $this->assertAnnounceContains('Loading table view.');
    hold_test_response(FALSE);
    $this->assertAnnounceContains('Changed to table view.');
    $this->assertMediaLibraryTable();
  }

  /**
   * Asserts that the grid display of the widget view is visible.
   */
  protected function assertMediaLibraryGrid() {
    $this->assertSession()->assertWaitOnAjaxRequest();
    $this->assertSession()
      ->elementExists('css', '.js-media-library-view[data-view-display-id="widget"]');
  }

  /**
   * Asserts that the table display of the widget view is visible.
   */
  protected function assertMediaLibraryTable() {
    $this->assertSession()
      ->elementExists('css', '.js-media-library-view[data-view-display-id="widget_table"]');
  }

  /**
   * Asserts the current text of the selected item counter.
   *
   * @param string $text
   *   The expected text of the counter.
   */
  protected function assertSelectedMediaCount($text) {
    $selected_count = $this->assertSession()
      ->elementExists('css', '.js-media-library-selected-count');

    $this->assertSame('status', $selected_count->getAttribute('role'));
    $this->assertSame('polite', $selected_count->getAttribute('aria-live'));
    $this->assertSame('true', $selected_count->getAttribute('aria-atomic'));
    $this->assertSame($text, $selected_count->getText());
  }

  /**
   * Checks for inclusion of text in #drupal-live-announce.
   *
   * @param string $expected_message
   *   The text expected to be present in #drupal-live-announce.
   *
   * @internal
   */
  protected function assertAnnounceContains(string $expected_message): void {
    $assert_session = $this->assertSession();
    $this->assertNotEmpty($assert_session->waitForElement('css', "#drupal-live-announce:contains('$expected_message')"));
  }

}
