<?php

declare(strict_types=1);

namespace Drupal\Tests\content_translation\Functional;

use Drupal\Core\Language\LanguageInterface;
use Drupal\Core\Url;
use Drupal\entity_test\Entity\EntityTestMulRevPub;
use Drupal\field\Entity\FieldConfig;
use Drupal\field\Entity\FieldStorageConfig;
use Drupal\Tests\system\Functional\Cache\AssertPageCacheContextsAndTagsTrait;
use Drupal\user\UserInterface;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;

/**
 * Tests the content translation workflows for the test entity.
 */
#[Group('content_translation')]
#[RunTestsInSeparateProcesses]
class ContentTranslationWorkflowsTest extends ContentTranslationTestBase {

  use AssertPageCacheContextsAndTagsTrait;

  /**
   * The entity used for testing.
   *
   * @var \Drupal\entity_test\Entity\EntityTestMul
   */
  protected $entity;

  /**
   * {@inheritdoc}
   */
  protected $entityTypeId = 'entity_test_mulrevpub';

  /**
   * The referencing entity.
   *
   * @var \Drupal\entity_test\Entity\EntityTestMul
   */
  protected $referencingEntity;

  /**
   * The entity owner account to be used to test multilingual entity editing.
   *
   * @var \Drupal\user\UserInterface
   */
  protected $entityOwner;

  /**
   * The user that has entity owner permission but is not the owner.
   *
   * @var \Drupal\user\UserInterface
   */
  protected $notEntityOwner;

  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'language',
    'content_translation',
    'entity_test',
  ];

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

  /**
   * {@inheritdoc}
   */
  protected function setUp(): void {
    parent::setUp();
    $this->doSetup();

    $field_storage = FieldStorageConfig::create([
      'field_name' => 'field_reference',
      'type' => 'entity_reference',
      'entity_type' => $this->entityTypeId,
      'cardinality' => 1,
      'settings' => [
        'target_type' => $this->entityTypeId,
      ],
    ]);
    $field_storage->save();
    FieldConfig::create([
      'field_storage' => $field_storage,
      'bundle' => $this->entityTypeId,
      'label' => 'Reference',
      'translatable' => FALSE,
    ])->save();

    $this->container->get('entity_display.repository')
      ->getViewDisplay($this->entityTypeId, $this->entityTypeId, 'default')
      ->setComponent('field_reference', [
        'type' => 'entity_reference_entity_view',
      ])
      ->save();

    $this->setupEntity();

    // Create a second entity that references the first to test how the
    // translation can be viewed through an entity reference field.
    $this->referencingEntity = EntityTestMulRevPub::create([
      'name' => 'referencing',
      'field_reference' => $this->entity->id(),
    ]);
    $this->referencingEntity->addTranslation($this->langcodes[2], $this->referencingEntity->toArray());
    $this->referencingEntity->save();
  }

  /**
   * {@inheritdoc}
   */
  protected function setupUsers(): void {
    $this->entityOwner = $this->drupalCreateUser($this->getEntityOwnerPermissions(), 'entity_owner');
    $this->notEntityOwner = $this->drupalCreateUser();
    $this->notEntityOwner->set('roles', $this->entityOwner->getRoles(TRUE));
    $this->notEntityOwner->save();
    parent::setupUsers();
  }

  /**
   * Returns an array of permissions needed for the entity owner.
   */
  protected function getEntityOwnerPermissions(): array {
    return [
      'edit own entity_test content',
      'translate editable entities',
      'view test entity',
      'view test entity translations',
      'view unpublished test entity translations',
    ];
  }

  /**
   * {@inheritdoc}
   */
  protected function getTranslatorPermissions() {
    $permissions = parent::getTranslatorPermissions();
    $permissions[] = 'view test entity';
    $permissions[] = 'view test entity translations';
    $permissions[] = 'view unpublished test entity translations';

    return $permissions;
  }

  /**
   * {@inheritdoc}
   */
  protected function getEditorPermissions(): array {
    return ['administer entity_test content', 'view test entity', 'view test entity translations'];
  }

  /**
   * Creates a test entity and translate it.
   *
   * @param \Drupal\user\UserInterface|null $user
   *   (optional) The entity owner.
   */
  protected function setupEntity(?UserInterface $user = NULL): void {
    $default_langcode = $this->langcodes[0];

    // Create a test entity.
    $user = $user ?: $this->drupalCreateUser();
    $values = [
      'name' => $this->randomMachineName(),
      'user_id' => $user->id(),
      $this->fieldName => [['value' => $this->randomMachineName(16)]],
    ];
    $id = $this->createEntity($values, $default_langcode);
    $storage = $this->container->get('entity_type.manager')
      ->getStorage($this->entityTypeId);

    // Create a translation that is not published to test view access.
    $this->drupalLogin($this->translator);
    $add_translation_url = Url::fromRoute(
      "entity.$this->entityTypeId.content_translation_add",
      [
        $this->entityTypeId => $id,
        'source' => $default_langcode,
        'target' => $this->langcodes[2],
      ],
    );
    $edit = [
      'name[0][value]' => 'translation name',
      'content_translation[status]' => FALSE,
    ];
    $this->drupalGet($add_translation_url);
    $this->submitForm($edit, 'Save');

    $storage->resetCache([$id]);
    $this->entity = $storage->load($id);

    $this->rebuildContainer();
  }

  /**
   * Tests simple and editorial translation workflows.
   */
  public function testWorkflows(): void {
    // Test workflows for the editor.
    $expected_status = [
      'edit' => 200,
      'delete' => 200,
      'overview' => 403,
      'add_translation' => 403,
      'edit_translation' => 403,
      'delete_translation' => 403,
      'view_unpublished_translation' => 403,
      'view_unpublished_translation_reference' => FALSE,
    ];
    $this->doTestWorkflows($this->editor, $expected_status);

    // Test workflows for the translator.
    $expected_status = [
      'edit' => 403,
      'delete' => 403,
      'overview' => 200,
      'add_translation' => 200,
      'edit_translation' => 200,
      'delete_translation' => 200,
      'view_unpublished_translation' => 200,
      'view_unpublished_translation_reference' => TRUE,
    ];
    $this->doTestWorkflows($this->translator, $expected_status);

    // Test workflows for the admin.
    $expected_status = [
      'edit' => 200,
      'delete' => 200,
      'overview' => 200,
      'add_translation' => 200,
      'edit_translation' => 403,
      'delete_translation' => 403,
      'view_unpublished_translation' => 200,
      'view_unpublished_translation_reference' => TRUE,
    ];
    $this->doTestWorkflows($this->administrator, $expected_status);

    // Check that translation permissions allow the associated operations.
    $ops = ['create' => 'Add', 'update' => 'Edit', 'delete' => 'Delete'];
    $translations_url = $this->entity->toUrl('drupal:content-translation-overview');
    foreach ($ops as $current_op => $item) {
      $user = $this->drupalCreateUser([
        $this->getTranslatePermission(),
        "$current_op content translations",
        'view test entity',
      ]);
      $this->drupalLogin($user);
      $this->drupalGet($translations_url);

      // Make sure that the user.permissions cache context and the cache tags
      // for the entity are present.
      $this->assertCacheContext('user.permissions');
      foreach ($this->entity->getCacheTags() as $cache_tag) {
        $this->assertSession()->responseHeaderContains('X-Drupal-Cache-Tags', $cache_tag);
      }

      foreach ($ops as $op => $label) {
        if ($op != $current_op) {
          $this->assertSession()->linkNotExists($label);
        }
        else {
          $this->assertSession()->linkExists($label, 0);
        }
      }
    }

    // Test workflows for the entity owner with non-editable content.
    $expected_status = [
      'edit' => 403,
      'delete' => 403,
      'overview' => 403,
      'add_translation' => 403,
      'edit_translation' => 403,
      'delete_translation' => 403,
      'view_unpublished_translation' => 200,
      'view_unpublished_translation_reference' => TRUE,
    ];
    $this->doTestWorkflows($this->entityOwner, $expected_status);

    // Test workflows for the entity owner with editable content.
    $this->setupEntity($this->entityOwner);
    $this->referencingEntity->set('field_reference', $this->entity->id());
    $this->referencingEntity->save();
    $expected_status = [
      'edit' => 200,
      'delete' => 403,
      'overview' => 200,
      'add_translation' => 200,
      'edit_translation' => 200,
      'delete_translation' => 200,
      'view_unpublished_translation' => 200,
      'view_unpublished_translation_reference' => TRUE,
    ];
    $this->doTestWorkflows($this->entityOwner, $expected_status);
    $expected_status = [
      'edit' => 403,
      'delete' => 403,
      'overview' => 403,
      'add_translation' => 403,
      'edit_translation' => 403,
      'delete_translation' => 403,
      'view_unpublished_translation' => 200,
      'view_unpublished_translation_reference' => TRUE,
    ];
    $this->doTestWorkflows($this->notEntityOwner, $expected_status);
  }

  /**
   * Checks that workflows have the expected behaviors for the given user.
   *
   * @param \Drupal\user\UserInterface $user
   *   The user to test the workflow behavior against.
   * @param array $expected_status
   *   The an associative array with the operation name as key and the expected
   *   status as value.
   */
  protected function doTestWorkflows(UserInterface $user, $expected_status): void {
    $default_langcode = $this->langcodes[0];
    $languages = $this->container->get('language_manager')->getLanguages();
    $options = ['language' => $languages[$default_langcode], 'absolute' => TRUE];
    $this->drupalLogin($user);

    // Check whether the user is allowed to access the entity form in edit mode.
    $edit_url = $this->entity->toUrl('edit-form', $options);
    $this->drupalGet($edit_url, $options);
    $this->assertSession()->statusCodeEquals($expected_status['edit']);

    // Check whether the user is allowed to access the entity delete form.
    $delete_url = $this->entity->toUrl('delete-form', $options);
    $this->drupalGet($delete_url, $options);
    $this->assertSession()->statusCodeEquals($expected_status['delete']);

    // Check whether the user is allowed to access the translation overview.
    $langcode = $this->langcodes[1];
    $options['language'] = $languages[$langcode];
    $translations_url = $this->entity->toUrl('drupal:content-translation-overview', $options)->toString();
    $this->drupalGet($translations_url);
    $this->assertSession()->statusCodeEquals($expected_status['overview']);

    // Check whether the user is allowed to create a translation.
    $add_translation_url = Url::fromRoute(
      "entity.$this->entityTypeId.content_translation_add",
      [
        $this->entityTypeId => $this->entity->id(),
        'source' => $default_langcode,
        'target' => $langcode,
      ],
      $options,
    );
    if ($expected_status['add_translation'] == 200) {
      $this->clickLink('Add');
      $this->assertSession()->addressEquals($add_translation_url);
      // Check that the translation form does not contain shared elements for
      // translators.
      if ($expected_status['edit'] == 403) {
        $this->assertNoSharedElements();
      }
    }
    else {
      $this->drupalGet($add_translation_url);
    }
    $this->assertSession()->statusCodeEquals($expected_status['add_translation']);

    // Check whether the user is allowed to edit a translation.
    $langcode = $this->langcodes[2];
    $options['language'] = $languages[$langcode];
    $edit_translation_url = Url::fromRoute(
      "entity.$this->entityTypeId.content_translation_edit",
      [
        $this->entityTypeId => $this->entity->id(),
        'language' => $langcode,
      ],
      $options,
    );
    if ($expected_status['edit_translation'] == 200) {
      $this->drupalGet($translations_url);
      $editor = $expected_status['edit'] == 200;

      if ($editor) {
        $this->clickLink('Edit', 1);
        // An editor should be pointed to the entity form in multilingual mode.
        // We need a new expected edit path with a new language.
        $expected_edit_path = $this->entity->toUrl('edit-form', $options)->toString();
        $this->assertSession()->addressEquals($expected_edit_path);
      }
      else {
        $this->clickLink('Edit');
        // While a translator should be pointed to the translation form.
        $this->assertSession()->addressEquals($edit_translation_url);
        // Check that the translation form does not contain shared elements.
        $this->assertNoSharedElements();
      }
    }
    else {
      $this->drupalGet($edit_translation_url);
    }
    $this->assertSession()->statusCodeEquals($expected_status['edit_translation']);

    // When viewing an unpublished entity directly, access is currently denied
    // completely. See https://www.drupal.org/node/2978048.
    $this->drupalGet($this->entity->getTranslation($langcode)->toUrl());
    $this->assertSession()->statusCodeEquals($expected_status['view_unpublished_translation']);

    // On a reference field, the translation falls back to the default language.
    $this->drupalGet($this->referencingEntity->getTranslation($langcode)->toUrl());
    $this->assertSession()->statusCodeEquals(200);
    if ($expected_status['view_unpublished_translation_reference']) {
      $this->assertSession()->pageTextContains('translation name');
    }
    else {
      $this->assertSession()->pageTextContains($this->entity->label());
    }

    // Check whether the user is allowed to delete a translation.
    $delete_translation_url = Url::fromRoute(
      "entity.$this->entityTypeId.content_translation_delete",
      [
        $this->entityTypeId => $this->entity->id(),
        'language' => $langcode,
      ],
      $options,
    );
    if ($expected_status['delete_translation'] == 200) {
      $this->drupalGet($translations_url);
      $editor = $expected_status['delete'] == 200;

      if ($editor) {
        $this->clickLink('Delete', 1);
        // An editor should be pointed to the entity deletion form in
        // multilingual mode. We need a new expected delete path with a new
        // language.
        $expected_delete_path = $this->entity->toUrl('delete-form', $options)->toString();
        $this->assertSession()->addressEquals($expected_delete_path);
      }
      else {
        $this->clickLink('Delete');
        // While a translator should be pointed to the translation deletion
        // form.
        $this->assertSession()->addressEquals($delete_translation_url);
      }
    }
    else {
      $this->drupalGet($delete_translation_url);
    }
    $this->assertSession()->statusCodeEquals($expected_status['delete_translation']);
  }

  /**
   * Assert that the current page does not contain shared form elements.
   *
   * @internal
   */
  protected function assertNoSharedElements(): void {
    $language_none = LanguageInterface::LANGCODE_NOT_SPECIFIED;
    $this->assertSession()->fieldNotExists("field_test_text[$language_none][0][value]");
  }

}
