<?php

declare(strict_types=1);

namespace Drupal\Tests\layout_builder\Functional;

use Drupal\Core\Url;
use Drupal\Tests\BrowserTestBase;
use Drupal\Tests\field\Traits\EntityReferenceFieldCreationTrait;
use Drupal\Tests\node\Traits\ContentTypeCreationTrait;
use Drupal\Tests\node\Traits\NodeCreationTrait;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;

/**
 * Tests cache tags on entity reference field blocks in Layout Builder.
 */
#[Group('layout_builder')]
#[RunTestsInSeparateProcesses]
class LayoutBuilderFieldBlockEntityReferenceCacheTagsTest extends BrowserTestBase {

  use ContentTypeCreationTrait;
  use EntityReferenceFieldCreationTrait;
  use NodeCreationTrait;

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

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

  /**
   * {@inheritdoc}
   */
  protected function setUp(): void {
    parent::setUp();

    // Enable page caching.
    $config = $this->config('system.performance');
    $config->set('cache.page.max_age', 3600);
    $config->save();

    // Create two content types, with one content type containing a field that
    // references entities of the second content type.
    $this->createContentType([
      'type' => 'bundle_with_reference_field',
      'name' => 'bundle_with_reference_field',
    ]);
    $this->createContentType([
      'type' => 'bundle_referenced',
      'name' => 'bundle_referenced',
    ]);

    $this->createEntityReferenceField('node', 'bundle_with_reference_field', 'field_reference', 'Reference field', 'node', 'default', [
      'target_bundles' => ['bundle_referenced'],
    ]);

    // Enable layout builder to the content type with the reference field, and
    // add the reference field to the layout builder display.
    $this->container->get('entity_display.repository')
      ->getViewDisplay('node', 'bundle_with_reference_field', 'full')
      ->enableLayoutBuilder()
      ->setComponent('field_reference', ['type' => 'entity_reference_label'])
      ->save();
  }

  /**
   * Tests cache tags on field block for entity reference field.
   */
  public function testEntityReferenceFieldBlockCaching(): void {
    $assert_session = $this->assertSession();

    // Create two nodes, one of the referenced content type and one of the
    // referencing content type, with the first node being referenced by the
    // second. Set the referenced node to be unpublished so anonymous user will
    // not have view access.
    $referenced_node = $this->createNode([
      'type' => 'bundle_referenced',
      'title' => 'The referenced node title',
      'status' => 0,
    ]);

    $referencing_node = $this->createNode([
      'type' => 'bundle_with_reference_field',
      'title' => 'The referencing node title',
      'field_reference' => ['entity' => $referenced_node],
    ]);

    // When user does not have view access to referenced entities in entity
    // reference field blocks, test that the cache tags of the referenced entity
    // are still bubbled to page cache.
    $referencing_node_url = $referencing_node->toUrl();
    $this->verifyPageCacheContainsTags($referencing_node_url, 'MISS');
    $this->verifyPageCacheContainsTags($referencing_node_url, 'HIT', $referenced_node->getCacheTags());
    // Since the referenced node is inaccessible, it should not appear on the
    // referencing node.
    $this->drupalGet($referencing_node_url);
    $assert_session->linkNotExists('The referenced node title');

    // Publish the referenced entity.
    $referenced_node->setPublished()
      ->save();

    // Revisit the node with the reference field without clearing cache. Now
    // that the referenced node is published, it should appear.
    $this->verifyPageCacheContainsTags($referencing_node_url, 'MISS');
    $this->verifyPageCacheContainsTags($referencing_node_url, 'HIT', $referenced_node->getCacheTags());
    $this->drupalGet($referencing_node_url);
    $assert_session->linkExists('The referenced node title');
  }

  /**
   * Verify that when loading a given page, it's a page cache hit or miss.
   *
   * @param \Drupal\Core\Url $url
   *   The page for this URL will be loaded.
   * @param string $hit_or_miss
   *   'HIT' if a page cache hit is expected, 'MISS' otherwise.
   * @param array|false $tags
   *   When expecting a page cache hit, you may optionally specify an array of
   *   expected cache tags. While FALSE, the cache tags will not be verified.
   *   This tests whether all expected tags are in the page cache tags, not that
   *   expected tags and page cache tags are identical.
   */
  protected function verifyPageCacheContainsTags(Url $url, $hit_or_miss, $tags = FALSE): void {
    $this->drupalGet($url);
    $this->assertSession()->responseHeaderEquals('X-Drupal-Cache', $hit_or_miss);

    if ($hit_or_miss === 'HIT' && is_array($tags)) {
      $cache_tags = explode(' ', $this->getSession()->getResponseHeader('X-Drupal-Cache-Tags'));
      $tags = array_unique($tags);
      $this->assertEmpty(array_diff($tags, $cache_tags), 'Page cache tags contains all expected tags.');
    }
  }

}
