<?php

namespace Drupal\views;

/**
 * Static service container wrapper for views.
 */
class Views {

  /**
   * The translation manager.
   *
   * @var \Drupal\Core\StringTranslation\TranslationInterface
   */
  protected static $translationManager;

  /**
   * A static cache for handler types data.
   *
   * @var array
   */
  protected static $handlerTypes;

  /**
   * A list of all available views plugin types.
   *
   * @var array
   */
  protected static $plugins = [
    'access' => 'plugin',
    'area' => 'handler',
    'argument' => 'handler',
    'argument_default' => 'plugin',
    'argument_validator' => 'plugin',
    'cache' => 'plugin',
    'display_extender' => 'plugin',
    'display' => 'plugin',
    'exposed_form' => 'plugin',
    'field' => 'handler',
    'filter' => 'handler',
    'join' => 'plugin',
    'pager' => 'plugin',
    'query' => 'plugin',
    'relationship' => 'handler',
    'row' => 'plugin',
    'sort' => 'handler',
    'style' => 'plugin',
    'wizard' => 'plugin',
  ];

  /**
   * Returns the views data service.
   *
   * @return \Drupal\views\ViewsData
   *   Returns a views data cache object.
   */
  public static function viewsData() {
    return \Drupal::service('views.views_data');
  }

  /**
   * Returns the views data helper service.
   *
   * @return \Drupal\views\ViewsDataHelper
   *   Returns a views data helper object.
   */
  public static function viewsDataHelper() {
    return \Drupal::service('views.views_data_helper');
  }

  /**
   * Returns the view executable factory service.
   *
   * @return \Drupal\views\ViewExecutableFactory
   *   Returns a views executable factory.
   */
  public static function executableFactory() {
    return \Drupal::service('views.executable');
  }

  /**
   * Returns the view analyzer.
   *
   * @return \Drupal\views\Analyzer
   *   Returns a view analyzer object.
   */
  public static function analyzer() {
    return \Drupal::service('views.analyzer');
  }

  /**
   * Returns the plugin manager for a certain views plugin type.
   *
   * @param string $type
   *   The plugin type, for example filter.
   *
   * @return \Drupal\views\Plugin\ViewsPluginManager
   */
  public static function pluginManager($type) {
    return \Drupal::service('plugin.manager.views.' . $type);
  }

  /**
   * Returns the plugin manager for a certain views handler type.
   *
   * @return \Drupal\views\Plugin\ViewsHandlerManager
   */
  public static function handlerManager($type) {
    return \Drupal::service('plugin.manager.views.' . $type);
  }

  /**
   * Loads a view from configuration and returns its executable object.
   *
   * @param string $id
   *   The view ID to load.
   *
   * @return \Drupal\views\ViewExecutable|null
   *   A view executable instance or NULL if the view does not exist.
   */
  public static function getView($id) {
    $view = \Drupal::entityTypeManager()->getStorage('view')->load($id);
    if ($view) {
      return static::executableFactory()->get($view);
    }
    return NULL;
  }

  /**
   * Fetches a list of all base tables available.
   *
   * @param string $type
   *   Either 'display', 'style' or 'row'.
   * @param string $key
   *   For style plugins, this is an optional type to restrict to. May be
   *   'normal', 'summary', 'feed' or others based on the needs of the display.
   * @param array $base
   *   An array of possible base tables.
   *
   * @return array
   *   A keyed array of in the form of 'base_table' => 'Description'.
   */
  public static function fetchPluginNames($type, $key = NULL, array $base = []) {
    $definitions = static::pluginManager($type)->getDefinitions();
    $plugins = [];

    foreach ($definitions as $id => $plugin) {
      // Skip plugins that don't conform to our key, if they have one.
      if ($key && isset($plugin['display_types']) && !in_array($key, $plugin['display_types'])) {
        continue;
      }

      if (empty($plugin['no_ui']) && (empty($base) || empty($plugin['base']) || array_intersect($base, $plugin['base']))) {
        $plugins[$id] = $plugin['title'];
      }
    }

    if (!empty($plugins)) {
      asort($plugins);
      return $plugins;
    }

    return $plugins;
  }

  /**
   * Gets all the views plugin definitions.
   *
   * @return array
   *   An array of plugin definitions for all types.
   */
  public static function getPluginDefinitions() {
    $plugins = [];
    foreach (ViewExecutable::getPluginTypes() as $plugin_type) {
      $plugins[$plugin_type] = static::pluginManager($plugin_type)->getDefinitions();
    }

    return $plugins;
  }

  /**
   * Gets enabled display extenders.
   */
  public static function getEnabledDisplayExtenders() {
    $enabled = array_filter((array) \Drupal::config('views.settings')->get('display_extenders'));

    return array_combine($enabled, $enabled);
  }

  /**
   * Gets view and display IDs for a given setting in display plugin settings.
   *
   * Return a list of all view IDs and display IDs that have a particular
   * setting in their display's plugin settings.
   *
   * @param string $type
   *   A flag from the display plugin definitions (e.g, 'uses_menu_links').
   *
   * @return array
   *   A list of arrays containing the $view_id and $display_id.
   *
   * @code
   * [
   *   [$view_id, $display_id],
   *   [$view_id, $display_id],
   * ];
   * @endcode
   */
  public static function getApplicableViews($type) {
    // Get all display plugins which provides the type.
    $display_plugins = static::pluginManager('display')->getDefinitions();

    $plugin_ids = [];
    foreach ($display_plugins as $id => $definition) {
      if (!empty($definition[$type])) {
        $plugin_ids[$id] = $id;
      }
    }

    $entity_ids = \Drupal::entityQuery('view')
      ->condition('status', TRUE)
      ->condition("display.*.display_plugin", $plugin_ids, 'IN')
      ->execute();

    $result = [];
    foreach (\Drupal::entityTypeManager()->getStorage('view')->loadMultiple($entity_ids) as $view) {
      // Check each display to see if it meets the criteria and is enabled.

      foreach ($view->get('display') as $id => $display) {
        // If the key doesn't exist, enabled is assumed.
        $enabled = !empty($display['display_options']['enabled']) || !array_key_exists('enabled', $display['display_options']);

        if ($enabled && in_array($display['display_plugin'], $plugin_ids)) {
          $result[] = [$view->id(), $id];
        }
      }
    }

    return $result;
  }

  /**
   * Returns an array of all views as fully loaded $view objects.
   *
   * @return \Drupal\views\Entity\View[]
   *   An array of loaded view entities.
   */
  public static function getAllViews() {
    return \Drupal::entityTypeManager()->getStorage('view')->loadMultiple();
  }

  /**
   * Returns an array of all enabled views.
   *
   * @return \Drupal\views\Entity\View[]
   *   An array of loaded enabled view entities.
   */
  public static function getEnabledViews() {
    $query = \Drupal::entityQuery('view')
      ->condition('status', TRUE)
      ->execute();

    return \Drupal::entityTypeManager()->getStorage('view')->loadMultiple($query);
  }

  /**
   * Returns an array of all disabled views.
   *
   * @return \Drupal\views\Entity\View[]
   *   An array of loaded disabled view entities.
   */
  public static function getDisabledViews() {
    $query = \Drupal::entityQuery('view')
      ->condition('status', FALSE)
      ->execute();

    return \Drupal::entityTypeManager()->getStorage('view')->loadMultiple($query);
  }

  /**
   * Returns an array of view as options array.
   *
   * This array can be used by select, checkboxes and radios as #options.
   *
   * @param bool $views_only
   *   If TRUE, only return views, not displays.
   * @param string $filter
   *   Filters the views on status. Can either be 'all' (default), 'enabled' or
   *   'disabled'
   * @param \Drupal\views\ViewExecutable|string $exclude_view
   *   View or current display to exclude.
   *   Either a:
   *   - Views executable object
   *   - views name, for example 'my_view'
   *   - views name and display ID separated by ':', for example 'my_view:page'
   * @param bool $optgroup
   *   If TRUE, returns an array with optgroups for each view (will be ignored for
   *   $views_only = TRUE). Can be used by select
   * @param bool $sort
   *   If TRUE, the list of views is sorted ascending.
   *
   * @return array
   *   An associative array for use in select.
   *   - key: view name and display ID separated by ':', or the view name only.
   */
  public static function getViewsAsOptions($views_only = FALSE, $filter = 'all', $exclude_view = NULL, $optgroup = FALSE, $sort = FALSE) {

    // Filter the big views array.
    switch ($filter) {
      case 'all':
      case 'disabled':
      case 'enabled':
        $filter = ucfirst($filter);
        $views = call_user_func(static::class . "::get{$filter}Views");
        break;

      default:
        return [];
    }

    // Prepare exclude view strings for comparison.
    if (empty($exclude_view)) {
      $exclude_view_name = '';
      $exclude_view_display = '';
    }
    elseif (is_object($exclude_view)) {
      $exclude_view_name = $exclude_view->storage->id();
      $exclude_view_display = $exclude_view->current_display;
    }
    else {
      // Append a ':' to the $exclude_view string so we always have more than one
      // item to explode.
      [$exclude_view_name, $exclude_view_display] = explode(':', "$exclude_view:");
    }

    $options = [];
    foreach ($views as $view) {
      $id = $view->id();
      // Return only views.
      if ($views_only && $id != $exclude_view_name) {
        $options[$id] = $view->label();
      }
      // Return views with display ids.
      else {
        foreach ($view->get('display') as $display_id => $display) {
          if (!($id == $exclude_view_name && $display_id == $exclude_view_display)) {
            if ($optgroup) {
              $options[$id][$id . ':' . $display['id']] = t('@view : @display', ['@view' => $id, '@display' => $display['id']]);
            }
            else {
              $options[$id . ':' . $display['id']] = t('View: @view - Display: @display', ['@view' => $id, '@display' => $display['id']]);
            }
          }
        }
      }
    }
    if ($sort) {
      ksort($options);
    }
    return $options;
  }

  /**
   * Returns a list of plugins and metadata about them.
   *
   * @return array
   *   An array keyed by PLUGIN_TYPE:PLUGIN_NAME, like 'display:page' or
   *   'pager:full', containing an array with the following keys:
   *   - title: The plugin's title.
   *   - type: The plugin type.
   *   - module: The module providing the plugin.
   *   - views: An array of enabled Views that are currently using this plugin,
   *     keyed by machine name.
   */
  public static function pluginList() {
    $plugin_data = static::getPluginDefinitions();
    $plugins = [];
    foreach (static::getEnabledViews() as $view) {
      foreach ($view->get('display') as $display) {
        foreach ($plugin_data as $type => $info) {
          if ($type == 'display' && isset($display['display_plugin'])) {
            $name = $display['display_plugin'];
          }
          elseif (isset($display['display_options']["{$type}_plugin"])) {
            $name = $display['display_options']["{$type}_plugin"];
          }
          elseif (isset($display['display_options'][$type]['type'])) {
            $name = $display['display_options'][$type]['type'];
          }
          else {
            continue;
          }

          // Key first by the plugin type, then the name.
          $key = $type . ':' . $name;
          // Add info for this plugin.
          if (!isset($plugins[$key])) {
            $plugins[$key] = [
              'type' => $type,
              'title' => $info[$name]['title'],
              'provider' => $info[$name]['provider'],
              'views' => [],
            ];
          }

          // Add this view to the list for this plugin.
          $plugins[$key]['views'][$view->id()] = $view->id();
        }
      }
    }
    return $plugins;
  }

  /**
   * Provide a list of views handler types used in a view.
   *
   * Also provides some information about them.
   *
   * @return array
   *   An array of associative arrays containing:
   *   - title: The title of the handler type.
   *   - ltitle: The lowercase title of the handler type.
   *   - stitle: A singular title of the handler type.
   *   - lstitle: A singular lowercase title of the handler type.
   *   - plural: Plural version of the handler type.
   *   - (optional) type: The actual internal used handler type. This key is
   *     just used for header,footer,empty to link to the internal type: area.
   */
  public static function getHandlerTypes() {
    // Statically cache this so translation only occurs once per request for all
    // of these values.
    if (!isset(static::$handlerTypes)) {
      static::$handlerTypes = [
        'field' => [
          // title
          'title' => static::t('Fields'),
          // Lowercase title for mid-sentence.
          'ltitle' => static::t('fields'),
          // Singular title.
          'stitle' => static::t('Field'),
          // Singular lowercase title for mid sentence
          'lstitle' => static::t('field'),
          'plural' => 'fields',
        ],
        'argument' => [
          'title' => static::t('Contextual filters'),
          'ltitle' => static::t('contextual filters'),
          'stitle' => static::t('Contextual filter'),
          'lstitle' => static::t('contextual filter'),
          'plural' => 'arguments',
        ],
        'sort' => [
          'title' => static::t('Sort criteria'),
          'ltitle' => static::t('sort criteria'),
          'stitle' => static::t('Sort criterion'),
          'lstitle' => static::t('sort criterion'),
          'plural' => 'sorts',
        ],
        'filter' => [
          'title' => static::t('Filter criteria'),
          'ltitle' => static::t('filter criteria'),
          'stitle' => static::t('Filter criterion'),
          'lstitle' => static::t('filter criterion'),
          'plural' => 'filters',
        ],
        'relationship' => [
          'title' => static::t('Relationships'),
          'ltitle' => static::t('relationships'),
          'stitle' => static::t('Relationship'),
          'lstitle' => static::t('Relationship'),
          'plural' => 'relationships',
        ],
        'header' => [
          'title' => static::t('Header'),
          'ltitle' => static::t('header'),
          'stitle' => static::t('Header'),
          'lstitle' => static::t('Header'),
          'plural' => 'header',
          'type' => 'area',
        ],
        'footer' => [
          'title' => static::t('Footer'),
          'ltitle' => static::t('footer'),
          'stitle' => static::t('Footer'),
          'lstitle' => static::t('Footer'),
          'plural' => 'footer',
          'type' => 'area',
        ],
        'empty' => [
          'title' => static::t('No results behavior'),
          'ltitle' => static::t('no results behavior'),
          'stitle' => static::t('No results behavior'),
          'lstitle' => static::t('No results behavior'),
          'plural' => 'empty',
          'type' => 'area',
        ],
      ];
    }

    return static::$handlerTypes;
  }

  /**
   * Returns a list of plugin types.
   *
   * @param string $type
   *   (optional) filter the list of plugins by type. Available options are
   *   'plugin' or 'handler'.
   *
   * @return array
   *   An array of plugin types.
   */
  public static function getPluginTypes($type = NULL) {
    if ($type === NULL) {
      return array_keys(static::$plugins);
    }

    if (!in_array($type, ['plugin', 'handler'])) {
      throw new \Exception('Invalid plugin type used. Valid types are "plugin" or "handler".');
    }

    return array_keys(array_filter(static::$plugins, function ($plugin_type) use ($type) {
      return $plugin_type == $type;
    }));
  }

  /**
   * Translates a string to the current language or to a given language.
   *
   * See the t() documentation for details.
   */
  protected static function t($string, array $args = [], array $options = []) {
    if (empty(static::$translationManager)) {
      static::$translationManager = \Drupal::service('string_translation');
    }

    return static::$translationManager->translate($string, $args, $options);
  }

}
