<?php

namespace Drupal\recurring_events;

use Drupal\Core\StringTranslation\TranslationInterface;
use Drupal\Core\Database\Connection;
use Drupal\Core\Datetime\DrupalDateTime;
use Drupal\Core\Logger\LoggerChannelFactoryInterface;
use Drupal\recurring_events\Entity\EventSeries;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Messenger\Messenger;
use Drupal\datetime\Plugin\Field\FieldType\DateTimeItemInterface;
use Drupal\Core\Entity\EntityFieldManager;
use Drupal\Core\Field\FieldTypePluginManager;
use Drupal\Core\StringTranslation\StringTranslationTrait;
use Drupal\Core\Extension\ModuleHandlerInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\KeyValueStore\KeyValueFactoryInterface;
use Drupal\recurring_events\Entity\EventInstance;
use Drupal\field_inheritance\Entity\FieldInheritanceInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * Provides a service with helper functions useful during event creation.
 */
class EventCreationService {

  use StringTranslationTrait;

  /**
   * The translation interface.
   *
   * @var \Drupal\Core\StringTranslation\TranslationInterface
   */
  private $translation;

  /**
   * The database connection.
   *
   * @var \Drupal\Core\Database\Connection
   */
  private $database;

  /**
   * Logger Factory.
   *
   * @var \Drupal\Core\Logger\LoggerChannel
   */
  protected $loggerChannel;

  /**
   * The messenger service.
   *
   * @var \Drupal\Core\Messenger\Messenger
   */
  protected $messenger;

  /**
   * The field type plugin manager.
   *
   * @var Drupal\Core\Field\FieldTypePluginManager
   */
  protected $fieldTypePluginManager;

  /**
   * The entity field manager.
   *
   * @var Drupal\Core\Entity\EntityFieldManager
   */
  protected $entityFieldManager;

  /**
   * The module handler service.
   *
   * @var \Drupal\Core\Extension\ModuleHandlerInterface
   */
  protected $moduleHandler;

  /**
   * The entity type manager service.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;

  /**
   * The key value storage service.
   *
   * @var \Drupal\Core\KeyValueStore\KeyValueFactoryInterface
   */
  protected $keyValueStore;

  /**
   * Class constructor.
   *
   * @param \Drupal\Core\StringTranslation\TranslationInterface $translation
   *   The translation interface.
   * @param \Drupal\Core\Database\Connection $database
   *   The database connection.
   * @param \Drupal\Core\Logger\LoggerChannelFactoryInterface $logger
   *   The logger factory.
   * @param \Drupal\Core\Messenger\Messenger $messenger
   *   The messenger service.
   * @param \Drupal\Core\Field\FieldTypePluginManager $field_type_plugin_manager
   *   The field type plugin manager.
   * @param \Drupal\Core\Entity\EntityFieldManager $entity_field_manager
   *   The entity field manager.
   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
   *   The module handler service.
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The entity type manager service.
   * @param \Drupal\Core\KeyValueStore\KeyValueFactoryInterface $key_value
   *   The key value storage service.
   */
  public function __construct(TranslationInterface $translation, Connection $database, LoggerChannelFactoryInterface $logger, Messenger $messenger, FieldTypePluginManager $field_type_plugin_manager, EntityFieldManager $entity_field_manager, ModuleHandlerInterface $module_handler, EntityTypeManagerInterface $entity_type_manager, KeyValueFactoryInterface $key_value) {
    $this->translation = $translation;
    $this->database = $database;
    $this->loggerChannel = $logger->get('recurring_events');
    $this->messenger = $messenger;
    $this->fieldTypePluginManager = $field_type_plugin_manager;
    $this->entityFieldManager = $entity_field_manager;
    $this->moduleHandler = $module_handler;
    $this->entityTypeManager = $entity_type_manager;
    $this->keyValueStore = $key_value;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container) {
    return new static(
      $container->get('string_translation'),
      $container->get('database'),
      $container->get('logger.factory'),
      $container->get('messenger'),
      $container->get('plugin.manager.field.field_type'),
      $container->get('entity_field.manager'),
      $container->get('module_handler'),
      $container->get('entity_type.manager'),
      $container->get('keyvalue')
    );
  }

  /**
   * Check whether there have been form recurring configuration changes.
   *
   * @param Drupal\recurring_events\Entity\EventSeries $event
   *   The stored event series entity.
   * @param Drupal\Core\Form\FormStateInterface $form_state
   *   The form state of an updated event series entity.
   *
   * @return bool
   *   TRUE if recurring config changes, FALSE otherwise.
   */
  public function checkForFormRecurConfigChanges(EventSeries $event, FormStateInterface $form_state) {
    $entity_config = $this->convertArrayLowercaseSorted(
      (array) $this->convertEntityConfigToArray($event));
    $form_config = $this->convertArrayLowercaseSorted(
      (array) $this->convertFormConfigToArray($form_state));
    return !(serialize($entity_config) === serialize($form_config));
  }

  /**
   * Check whether there have been original recurring configuration changes.
   *
   * @param Drupal\recurring_events\Entity\EventSeries $event
   *   The stored event series entity.
   * @param Drupal\recurring_events\Entity\EventSeries $original
   *   The original stored event series entity.
   *
   * @return bool
   *   TRUE if recurring config changes, FALSE otherwise.
   */
  public function checkForOriginalRecurConfigChanges(EventSeries $event, EventSeries $original) {
    $entity_config = $this->convertArrayLowercaseSorted(
      (array) $this->convertEntityConfigToArray($event));
    $original_config = $this->convertArrayLowercaseSorted(
      (array) $this->convertEntityConfigToArray($original));
    return !(serialize($entity_config) === serialize($original_config));
  }

  /**
   * Converts an EventSeries entity's recurring configuration to an array.
   *
   * @param Drupal\recurring_events\Entity\EventSeries $event
   *   The stored event series entity.
   *
   * @return array
   *   The recurring configuration as an array.
   */
  public function convertEntityConfigToArray(EventSeries $event) {
    $config = [];
    $config['type'] = $event->getRecurType();
    $config['excluded_dates'] = $event->getExcludedDates();
    $config['included_dates'] = $event->getIncludedDates();

    if ($config['type'] === 'custom') {
      $config['custom_dates'] = $event->getCustomDates();
    }
    else {
      $field_definition = $this->fieldTypePluginManager->getDefinition($config['type']);
      $field_class = $field_definition['class'];
      $config += $field_class::convertEntityConfigToArray($event);
    }

    $this->moduleHandler->alter('recurring_events_entity_config_array', $config);

    return $config;
  }

  /**
   * Converts a form state object's recurring configuration to an array.
   *
   * @param Drupal\Core\Form\FormStateInterface $form_state
   *   The form state of an updated event series entity.
   *
   * @return array
   *   The recurring configuration as an array.
   */
  public function convertFormConfigToArray(FormStateInterface $form_state) {
    $config = [];

    $utc_timezone = new \DateTimeZone(DateTimeItemInterface::STORAGE_TIMEZONE);
    $user_input = $form_state->getValues();

    $config['type'] = $user_input['recur_type'][0]['value'];

    $config['excluded_dates'] = [];
    if (!empty($user_input['excluded_dates'])) {
      $config['excluded_dates'] = $this->getDatesFromForm($user_input['excluded_dates']);
    }

    $config['included_dates'] = [];
    if (!empty($user_input['included_dates'])) {
      $config['included_dates'] = $this->getDatesFromForm($user_input['included_dates']);
    }

    if ($config['type'] === 'custom') {
      foreach ($user_input['custom_date'] as $key => $custom_date) {
        if (!is_numeric($key)) {
          continue;
        }
        $start_date = $end_date = NULL;

        if (!empty($custom_date['value']) && !empty($custom_date['end_value'])) {

          $start_timestamp = $custom_date['value']->format(DateTimeItemInterface::DATETIME_STORAGE_FORMAT);
          $end_timestamp = $custom_date['end_value']->format(DateTimeItemInterface::DATETIME_STORAGE_FORMAT);
          $start_date = DrupalDateTime::createFromFormat(DateTimeItemInterface::DATETIME_STORAGE_FORMAT, $start_timestamp, $utc_timezone);
          $end_date = DrupalDateTime::createFromFormat(DateTimeItemInterface::DATETIME_STORAGE_FORMAT, $end_timestamp, $utc_timezone);

          $config['custom_dates'][] = [
            'start_date' => $start_date,
            'end_date' => $end_date,
          ];
        }
      }
    }
    else {
      $field_definition = $this->fieldTypePluginManager->getDefinition($config['type']);
      $field_class = $field_definition['class'];
      $config += $field_class::convertFormConfigToArray($form_state);
    }

    $this->moduleHandler->alter('recurring_events_form_config_array', $config);

    return $config;
  }

  /**
   * Normalize an array for equality checks, without having to worry about order
   * or casing discrepencies.
   *
   * @param array $input
   *   The array to clean and sort.
   *
   * @return array
   *   A cleaned array.
   */
  public static function convertArrayLowercaseSorted(array $input) {
    foreach ($input as $key => $val) {
      if (is_object($val)) {
        $input[$key] = self::convertArrayLowercaseSorted((array) $val);
      }
      if (is_array($val)) {
        $input[$key] = self::convertArrayLowercaseSorted($val);
      }
      if (is_string($val)) {
        $input[$key] = strtolower($val);
      }
    }
    uksort($input, 'strcmp');
    return $input;
  }

  /**
   * Build diff array between stored entity and form state.
   *
   * @param Drupal\recurring_events\Entity\EventSeries $event
   *   The stored event series entity.
   * @param Drupal\Core\Form\FormStateInterface $form_state
   *   (Optional) The form state of an updated event series entity.
   * @param Drupal\recurring_events\Entity\EventSeries $edited
   *   (Optional) The edited event series entity.
   *
   * @return array
   *   An array of differences.
   */
  public function buildDiffArray(EventSeries $event, FormStateInterface $form_state = NULL, EventSeries $edited = NULL) {
    $diff = [];

    $entity_config = $this->convertEntityConfigToArray($event);
    $form_config = [];

    if (!is_null($form_state)) {
      $form_config = $this->convertFormConfigToArray($form_state);
    }
    if (!is_null($edited)) {
      $form_config = $this->convertEntityConfigToArray($edited);
    }

    if (empty($form_config)) {
      return $diff;
    }

    if ($entity_config['type'] !== $form_config['type']) {
      $diff['type'] = [
        'label' => $this->translation->translate('Recur Type'),
        'stored' => $entity_config['type'],
        'override' => $form_config['type'],
      ];
    }
    else {
      if ($entity_config['excluded_dates'] !== $form_config['excluded_dates']) {
        $entity_dates = $this->buildDateString($entity_config['excluded_dates']);
        $config_dates = $this->buildDateString($form_config['excluded_dates']);
        $diff['excluded_dates'] = [
          'label' => $this->translation->translate('Excluded Dates'),
          'stored' => $entity_dates,
          'override' => $config_dates,
        ];
      }
      if ($entity_config['included_dates'] !== $form_config['included_dates']) {
        $entity_dates = $this->buildDateString($entity_config['included_dates']);
        $config_dates = $this->buildDateString($form_config['included_dates']);
        $diff['included_dates'] = [
          'label' => $this->translation->translate('Included Dates'),
          'stored' => $entity_dates,
          'override' => $config_dates,
        ];
      }

      if ($entity_config['type'] === 'custom') {
        if ($entity_config['custom_dates'] !== $form_config['custom_dates']) {
          $stored_start_ends = $overridden_start_ends = [];

          $user_timezone = new \DateTimeZone(date_default_timezone_get());

          foreach ($entity_config['custom_dates'] as $date) {
            if (!empty($date['start_date']) && !empty($date['end_date'])) {
              $date['start_date']->setTimezone($user_timezone);
              $date['end_date']->setTimezone($user_timezone);
              $stored_start_ends[] = $date['start_date']->format('Y-m-d h:ia') . ' - ' . $date['end_date']->format('Y-m-d h:ia');
            }
          }

          foreach ($form_config['custom_dates'] as $date) {
            if (!empty($date['start_date']) && !empty($date['end_date'])) {
              $date['start_date']->setTimezone($user_timezone);
              $date['end_date']->setTimezone($user_timezone);
              $overridden_start_ends[] = $date['start_date']->format('Y-m-d h:ia') . ' - ' . $date['end_date']->format('Y-m-d h:ia');
            }
          }

          $diff['custom_dates'] = [
            'label' => $this->translation->translate('Custom Dates'),
            'stored' => implode(', ', $stored_start_ends),
            'override' => implode(', ', $overridden_start_ends),
          ];
        }
      }
      else {
        $field_definition = $this->fieldTypePluginManager->getDefinition($entity_config['type']);
        $field_class = $field_definition['class'];
        $diff += $field_class::buildDiffArray($entity_config, $form_config);
      }
    }

    $this->moduleHandler->alter('recurring_events_diff_array', $diff);

    return $diff;
  }

  /**
   * Clear out existing event instances..
   *
   * @param Drupal\recurring_events\Entity\EventSeries $event
   *   The event series entity.
   */
  public function clearEventInstances(EventSeries $event) {
    // Allow other modules to react prior to the deletion of all instances.
    $this->moduleHandler->invokeAll('recurring_events_save_pre_instances_deletion', [
      $event
    ]);

    // Find all the instances and delete them.
    $instances = $event->event_instances->referencedEntities();
    if (!empty($instances)) {
      foreach ($instances as $instance) {
        // Allow other modules to react prior to deleting a specific
        // instance after a date configuration change.
        $this->moduleHandler->invokeAll('recurring_events_save_pre_instance_deletion', [
          $event,
          $instance,
        ]);

        $instance->delete();

        // Allow other modules to react after deleting a specific instance
        // after a date configuration change.
        $this->moduleHandler->invokeAll('recurring_events_save_post_instance_deletion', [
          $event,
          $instance,
        ]);
      }
      $this->messenger->addStatus($this->translation->translate('A total of %count existing event instances were removed', [
        '%count' => count($instances),
      ]));
    }

    // Allow other modules to react after the deletion of all instances.
    $this->moduleHandler->invokeAll('recurring_events_save_post_instances_deletion', [
      $event
    ]);

    $this->entityTypeManager->getStorage('eventseries')->resetCache([$event->id()]);
  }

  /**
   * Create the event instances from the form state.
   *
   * @param \Drupal\recurring_events\Entity\EventSeries $event
   *   The stored event series entity.
   *
   * @return \Drupal\recurring_events\Entity\EventInstance[]
   *   An array of event instances created for the series.
   *
   * @throws \Drupal\Component\Plugin\Exception\PluginNotFoundException
   */
  public function createInstances(EventSeries $event): array {
    $form_data = $this->convertEntityConfigToArray($event);
    $event_instances = [];

    if (!empty($form_data['type'])) {
      if ($form_data['type'] === 'custom') {
        if (!empty($form_data['custom_dates'])) {
          $events_to_create = [];
          foreach ($form_data['custom_dates'] as $date_range) {
            // Set this event to be created.
            $events_to_create[$date_range['start_date']->format('r')] = [
              'start_date' => $date_range['start_date'],
              'end_date' => $date_range['end_date'],
            ];
          }

          // Allow modules to alter the array of event instances before they
          // get created.
          $this->moduleHandler->alter('recurring_events_event_instances_pre_create', $events_to_create, $event);

          if (!empty($events_to_create)) {
            foreach ($events_to_create as $custom_event) {
              $instance = $this->createEventInstance($event, $custom_event['start_date'], $custom_event['end_date']);
              $this->configureDefaultInheritances($instance, $event->id());
              $event_instances[] = $instance;
            }
          }
        }
      }
      else {
        $field_definition = $this->fieldTypePluginManager->getDefinition($form_data['type']);
        $field_class = $field_definition['class'];
        $events_to_create = $field_class::calculateInstances($form_data);

        // Allow modules to alter the array of event instances before they
        // get created.
        $this->moduleHandler->alter('recurring_events_event_instances_pre_create', $events_to_create, $event);

        if (!empty($events_to_create)) {
          foreach ($events_to_create as $event_to_create) {
            $instance = $this->createEventInstance($event, $event_to_create['start_date'], $event_to_create['end_date']);
            $this->configureDefaultInheritances($instance, $event->id());
            $event_instances[] = $instance;
          }
        }
      }
    }

    // Create a message to indicate how many instances were changed.
    $this->messenger->addMessage($this->translation->translate('A total of %items event instances were created as part of this event series.', [
      '%items' => count($event_instances),
    ]));

    return $event_instances;
  }

  /**
   * Create an event instance from an event series.
   *
   * @param Drupal\recurring_events\Entity\EventSeries $event
   *   The stored event series entity.
   * @param Drupal\Core\Datetime\DrupalDateTime $start_date
   *   The start date and time of the event.
   * @param Drupal\Core\Datetime\DrupalDateTime $end_date
   *   The end date and time of the event.
   *
   * @return \Drupal\recurring_events\Entity\EventInstance
   *   The created event instance entity object.
   */
  public function createEventInstance(EventSeries $event, DrupalDateTime $start_date, DrupalDateTime $end_date) {
    $data = [
      'eventseries_id' => $event->id(),
      'date' => [
        'value' => $start_date->format(DateTimeItemInterface::DATETIME_STORAGE_FORMAT),
        'end_value' => $end_date->format(DateTimeItemInterface::DATETIME_STORAGE_FORMAT),
      ],
      'type' => $event->getType(),
      'uid' => $event->getOwnerId(),
    ];

    $this->moduleHandler->alter('recurring_events_event_instance', $data);

    $storage = $this->entityTypeManager->getStorage('eventinstance');
    if ($event->isDefaultTranslation()) {
      $entity = $storage->create($data);
    }
    else {
      // Grab the untranslated event series.
      $original = $event->getUntranslated();
      // Find the corresponding default language event instance that matches
      // the date and time of the version we wish to translate, so that we are
      // mapping the translations from default language to translated language
      // appropriately.
      $entity_ids = $storage->getQuery()
        ->condition('date__value', $data['date']['value'])
        ->condition('date__end_value', $data['date']['end_value'])
        ->condition('eventseries_id', $data['eventseries_id'])
        ->condition('type', $data['type'])
        ->condition('langcode', $original->language()->getId())
        ->accessCheck(FALSE)
        ->execute();

      if (!empty($entity_ids)) {
        // Load the default language version of the event instance.
        $entity = $storage->load(reset($entity_ids));
        // Only add a translation if we do not already have one.
        if (!$entity->hasTranslation($event->language()->getId())) {
          $entity->addTranslation($event->language()->getId(), $data);
        }
      }
    }

    if ($entity) {
      $entity->save();
    }
    else {
      $this->loggerChannel->warning('Missing event instance in default language. Translation could not be created');
    }

    return $entity;
  }

  /**
   * Configure the default field inheritances for event instances.
   *
   * @param Drupal\recurring_events\Entity\EventInstance $instance
   *   The event instance.
   * @param int $series_id
   *   The event series entity ID.
   */
  public function configureDefaultInheritances(EventInstance $instance, int $series_id = NULL) {
    if (is_null($series_id)) {
      $series_id = $instance->eventseries_id->target_id;
    }

    if (!empty($series_id)) {
      // Configure the field inheritances for this instance.
      $entity_type = $instance->getEntityTypeId();
      $bundle = $instance->bundle();

      $inherited_fields = $this->entityTypeManager->getStorage('field_inheritance')->loadByProperties([
        'sourceEntityType' => 'eventseries',
        'destinationEntityType' => $entity_type,
        'destinationEntityBundle' => $bundle,
      ]);

      if (!empty($inherited_fields)) {
        $state_key = $entity_type . ':' . $instance->uuid();
        $state = $this->keyValueStore->get('field_inheritance');
        $state_values = $state->get($state_key);
        if (empty($state_values)) {
          $state_values = [
            'enabled' => TRUE,
          ];
          if (!empty($inherited_fields)) {
            foreach ($inherited_fields as $inherited_field) {
              $name = $inherited_field->idWithoutTypeAndBundle();
              $state_values[$name] = [
                'entity' => $series_id,
              ];
            }
          }
          $state->set($state_key, $state_values);
        }
      }
    }
  }

  /**
   * When adding a new field inheritance, add the default values for it.
   *
   * @param Drupal\recurring_events\Entity\EventInstance $instance
   *   The event instance for which to configure default inheritance values.
   * @param Drupal\field_inheritance\Entity\FieldInheritanceInterface $field_inheritance
   *   The field inheritance being created or updated.
   */
  public function addNewDefaultInheritance(EventInstance $instance, FieldInheritanceInterface $field_inheritance) {
    $state_key = 'eventinstance:' . $instance->uuid();
    $state = $this->keyValueStore->get('field_inheritance');
    $state_values = $state->get($state_key);
    $name = $field_inheritance->idWithoutTypeAndBundle();

    if (!empty($state_values[$name])) {
      return;
    }

    $state_values[$name] = [
      'entity' => $instance->eventseries_id->target_id,
    ];

    $state->set($state_key, $state_values);
  }

  /**
   * Get exclude/include dates from form.
   *
   * @param array $field
   *   The field from which to retrieve the dates.
   *
   * @return array
   *   An array of dates.
   */
  private function getDatesFromForm(array $field) {
    $dates = [];

    if (!empty($field)) {
      foreach ($field as $key => $date) {
        if (!is_numeric($key)) {
          continue;
        }
        if (!empty($date['value']) && !empty($date['end_value'])) {
          $dates[] = [
            'value' => $date['value']->format('Y-m-d'),
            'end_value' => $date['end_value']->format('Y-m-d'),
          ];
        }
      }
    }
    return $dates;
  }

  /**
   * Build a string from excluded or included date ranges.
   *
   * @var array $config
   *   The configuration from which to build a string.
   *
   * @return string
   *   The formatted date string.
   */
  private function buildDateString(array $config) {
    $string = '';

    $string_parts = [];
    if (!empty($config)) {
      foreach ($config as $date) {
        $range = $this->translation->translate('@start_date to @end_date', [
          '@start_date' => $date['value'],
          '@end_date' => $date['end_value'],
        ]);
        $string_parts[] = '(' . $range . ')';
      }

      $string = implode(', ', $string_parts);
    }
    return $string;
  }

  /**
   * Retrieve the recur field types.
   *
   * @param bool $allow_alter
   *   Allow altering of the field types.
   *
   * @return array
   *   An array of field types.
   */
  public function getRecurFieldTypes($allow_alter = TRUE) {
    // Build an array of recur type field options based on FieldTypes that
    // implement the Drupal\recurring_events\RecurringEventsFieldTypeInterface
    // interface. Allow for other modules to customize this list with an alter
    // hook.
    $recur_fields = [];
    $fields = $this->entityFieldManager->getBaseFieldDefinitions('eventseries');
    foreach ($fields as $field) {
      $field_definition = $this->fieldTypePluginManager->getDefinition($field->getType());
      $class = new \ReflectionClass($field_definition['class']);
      if ($class->implementsInterface('\Drupal\recurring_events\RecurringEventsFieldTypeInterface')) {
        $recur_fields[$field->getName()] = $field->getLabel();
      }
    }

    $recur_fields['custom'] = $this->t('Custom/Single Event');
    if ($allow_alter) {
      $this->moduleHandler->alter('recurring_events_recur_field_types', $recur_fields);
    }
    return $recur_fields;
  }

  /**
   * Update instance status.
   *
   * @param Drupal\recurring_events\Entity\EventInstance $instance
   *   The event instance for which to update the status.
   * @param Drupal\recurring_events\Entity\EventSeries $event
   *   The event series entity.
   */
  public function updateInstanceStatus(EventInstance $instance, EventSeries $event) {
    $original_event = $event->original;
    $field_name = 'status';

    if ($this->moduleHandler->moduleExists('workflows')) {
      if ($event->hasField('moderation_state') && $instance->hasField('moderation_state')) {
        $series_query = $this->entityTypeManager->getStorage('workflow')->getQuery()->accessCheck(FALSE);
        $series_query->condition('type_settings.entity_types.eventseries.*', $event->bundle());
        $series_workflows = $series_query->accessCheck(FALSE)->execute();
        $series_workflows = array_keys($series_workflows);
        $series_workflow = reset($series_workflows);

        $instance_query = $this->entityTypeManager->getStorage('workflow')->getQuery()->accessCheck(FALSE);
        $instance_query->condition('type_settings.entity_types.eventinstance.*', $instance->bundle());
        $instance_workflows = $instance_query->accessCheck(FALSE)->execute();
        $instance_workflows = array_keys($instance_workflows);
        $instance_workflow = reset($instance_workflows);

        // We only want to mimic moderation state if the series and instance use
        // the same workflows, otherwise we cannot guarantee the states match.
        if ($instance_workflow === $series_workflow) {
          $field_name = 'moderation_state';
        }
        else {
          return FALSE;
        }
      }
    }

    $new_state = $event->get($field_name)->getValue();
    $instance_state = $instance->get($field_name)->getValue();

    if (!empty($original_event)) {
      $original_state = $original_event->get($field_name)->getValue();
    }
    else {
      $instance->set($field_name, $new_state);
      return TRUE;
    }

    // If the instance state matches the original state of the series we want
    // to also update the instance state.
    if ($instance_state === $original_state) {
      $instance->set($field_name, $new_state);
      return TRUE;
    }

    return FALSE;

  }

}