Demo: Field formatters

<?php

declare(strict_types=1);

namespace Drupal\gwt_demo\Plugin\ProjectDemo;

use Drupal\Component\Plugin\Definition\PluginDefinitionInterface;
use Drupal\Core\Field\FormatterInterface;
use Drupal\Core\Field\FormatterPluginManager;
use Drupal\Core\Form\FormBuilderInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\StringTranslation\TranslatableMarkup;
use Drupal\gwt_demo\Attribute\ProjectDemo;
use Drupal\gwt_demo\Form\FieldFormatterPlaygroundForm;
use Drupal\gwt_demo\ProjectDemo\FormatterPluginCollection;
use Drupal\gwt_demo\ProjectDemo\InteractiveProjectDemoInterface;
use Drupal\gwt_demo\ProjectDemo\PluginSystemDemoBase;
use Drupal\gwt_demo\Services\FormatterSamples;
use Symfony\Component\DependencyInjection\Attribute\Autowire;

/**
 * Sample field values through field formatters.
 *
 * Visitors pick a sample field and a formatter, change its settings and see
 * the result (FieldFormatterPlaygroundForm). The demo's settings choose
 * formatters for each sample field and their settings, kept in a formatter
 * plugin collection under the "formatters" key: the playground starts from
 * them, and the static export shows them all as a gallery. The sample fields
 * are in Services\FormatterSamples.
 */
#[ProjectDemo(
  id: 'field_formatters',
  label: new TranslatableMarkup('Field formatters'),
  description: new TranslatableMarkup('Visitors try field formatters and their settings on sample field values. The static export shows the formatters chosen here.'),
)]
final class FieldFormatterDemo extends PluginSystemDemoBase implements InteractiveProjectDemoInterface {

  public function __construct(
    array $configuration,
    $plugin_id,
    $plugin_definition,
    #[Autowire(service: 'plugin.manager.field.formatter')]
    FormatterPluginManager $pluginManager,
    protected FormatterSamples $samples,
    protected FormBuilderInterface $formBuilder,
  ) {
    parent::__construct($configuration, $plugin_id, $plugin_definition, $pluginManager);
  }

  /**
   * {@inheritdoc}
   */
  public function defaultConfiguration(): array {
    return ['formatters' => []];
  }

  /**
   * {@inheritdoc}
   */
  protected function createPluginCollections(): array {
    return ['formatters' => new FormatterPluginCollection($this->pluginManager, $this->configuration['formatters'], $this->samples)];
  }

  /**
   * {@inheritdoc}
   */
  protected function isListed(array|PluginDefinitionInterface $definition, string $plugin_id): bool {
    return (bool) array_intersect($definition['field_types'], array_keys($this->samples->getFieldDefinitions()));
  }

  /**
   * {@inheritdoc}
   */
  public function buildConfigurationForm(array $form, FormStateInterface $form_state): array {
    $form['formatters'] = ['#tree' => TRUE];
    foreach ($this->samples->getFieldDefinitions() as $field_type => $field) {
      $form['formatters'][$field_type] = [
        '#type' => 'fieldset',
        '#title' => $field->getLabel(),
      ];
      foreach ($this->samples->getFormatterDefinitions($field) as $id => $definition) {
        $instance_id = $field_type . ':' . $id;
        $used = isset($this->configuration['formatters'][$instance_id]);
        $formatter = $this->getPlugin('formatters', $instance_id);
        if (!$formatter instanceof FormatterInterface) {
          $formatter = $this->samples->createFormatter($field, $id);
        }
        $form['formatters'][$field_type][$id] = [
          '#type' => 'details',
          '#title' => $definition['label'],
          '#open' => $used,
          'used' => [
            '#type' => 'checkbox',
            '#title' => $this->t('Show this formatter'),
            '#default_value' => $used,
          ],
          'settings' => array_diff_key($formatter->settingsForm([], $form_state), FormatterSamples::LOCKED_SETTINGS),
        ];
      }
    }
    return $form;
  }

  /**
   * {@inheritdoc}
   */
  public function submitConfigurationForm(array &$form, FormStateInterface $form_state): void {
    $formatters = [];
    foreach ($form_state->getValue('formatters') ?? [] as $field_type => $values) {
      foreach (array_filter($values, fn(array $value) => !empty($value['used'])) as $id => $value) {
        $formatters[$field_type . ':' . $id] = [
          'field' => $field_type,
          'type' => $id,
          'settings' => $value['settings'] ?? [],
        ];
      }
    }
    // The base class copies form values to settings of the same name; the
    // form groups formatters by field instead.
    parent::submitConfigurationForm($form, $form_state);
    $this->configuration['formatters'] = $formatters;
  }

  /**
   * {@inheritdoc}
   */
  public function build(): array {
    return $this->formBuilder->getForm(FieldFormatterPlaygroundForm::class, $this->configuration['formatters']);
  }

  /**
   * {@inheritdoc}
   *
   * Every sample field through every formatter chosen for it.
   */
  public function buildStatic(): array {
    $fields = [];
    foreach ($this->samples->getFieldDefinitions() as $field_type => $field) {
      $items = $this->samples->createItems($field);
      $shown = [];
      foreach ($this->samples->getFormatterDefinitions($field) as $id => $definition) {
        $formatter = $this->getPlugin('formatters', $field_type . ':' . $id);
        if ($formatter instanceof FormatterInterface) {
          $shown[] = [
            'label' => $definition['label'],
            'id' => $id,
            'summary' => $this->samples->summarize($formatter, $field),
            'output' => $this->samples->view($formatter, $items),
          ];
        }
      }
      if ($shown) {
        $fields[] = [
          'label' => $field->getLabel(),
          'type' => $field_type,
          'value' => $this->samples->getStoredValue($items),
          'formatters' => $shown,
        ];
      }
    }
    return [
      '#theme' => 'gwt_demo_field_formatters',
      '#fields' => $fields,
    ];
  }

}