<?php

/**
 * @file
 * Install, update and uninstall functions for the Media module.
 */

/**
 * Implements hook_install().
 */
function media_install() {
  // Create initial display settings.
  module_load_include('inc', 'file_entity', 'file_entity.file_api');
  $default_image_styles = array(
    'preview' => 'media_thumbnail',
    'teaser' => 'medium',
    'full' => 'large',
  );
  // Only needed by sites that updated from Media 1.x.
  // @see media_entity_info_alter()
  if (variable_get('media__show_deprecated_view_modes')) {
    $default_image_styles['media_original'] = '';
  }

  foreach ($default_image_styles as $view_mode => $image_style) {
    $existing_display = file_displays_load('image', $view_mode);

    if (empty($existing_display)) {
      $display_name = 'image__' . $view_mode . '__file_image';
      $display = array(
        'api_version' => 1,
        'name' => $display_name,
        'status' => 1,
        'weight' => 5,
        'settings' => array('image_style' => $image_style),
        'export_type' => NULL,
      );
      file_display_save((object) $display);
    }
  }

  // Make sure that we set the icon base directory variable if it is not
  // already set.
  $base = variable_get('media__icon_base_directory', NULL);
  if (!isset($base)) {
    $default_base = 'public://media-icons';
    variable_set('media__icon_base_directory', $default_base);
  }
  try {
    _media_install_copy_icons();
  }
  catch (Exception $e) {
    watchdog_exception('media', $e);
  }
}

/**
 * Copy the media file icons to files directory for use with image styles.
 */
function _media_install_copy_icons() {
  $destination = variable_get('media__icon_base_directory', 'public://media-icons') . '/' . variable_get('media__icon_set', 'default');
  if (!file_prepare_directory($destination, FILE_CREATE_DIRECTORY)) {
    throw new Exception("Unable to create directory $destination.");
  }
  // @todo If we ever add another default icon set, this should copy all images from one directory up.
  $source = drupal_get_path('module', 'media') . '/images/icons/' . variable_get('media__icon_set', 'default');
  $files = file_scan_directory($source, '/.*\.(png|jpg)$/');
  foreach ($files as $file) {
    $result = file_unmanaged_copy($file->uri, $destination, FILE_EXISTS_REPLACE);
    if (!$result) {
      throw new Exception("Unable to copy {$file->uri} to $destination.");
    }
  }
}

/**
 * Implements hook_uninstall().
 */
function media_uninstall() {
  // Remove variables.
  variable_del('media__wysiwyg_title');
  variable_del('media__wysiwyg_icon_title');
  variable_del('media__wysiwyg_default_view_mode');
  variable_del('media__wysiwyg_upload_directory');
  variable_del('media__wysiwyg_allowed_types');
  variable_del('media__wysiwyg_allowed_attributes');
  variable_del('media__wysiwyg_browser_plugins');
  variable_del('media__dialog_theme');
  variable_del('media__max_filesize');
  variable_del('media__debug');
  variable_del('media__file_list_size');
  variable_del('media__xml_cache_expire');
  variable_del('media__import_batch_size');
  variable_del('media__fromurl_supported_schemes');
  variable_del('media__icon_base_directory');
  variable_del('media__icon_set');
  variable_del('media__show_deprecated_view_modes');
  variable_del('media__show_file_type_rebuild_nag');
  variable_del('media__field_select_media_text');
  variable_del('media__field_remove_media_text');
  variable_del('media__browser_library_empty_message');
  variable_del('media__browser_pager_limit');
  variable_del('media__browser_viewtype_default');
  variable_del('media__display_types_migration_mess');
}

/**
 * Implements hook_update_dependencies().
 */
function media_update_dependencies() {
  // media_update_7200() needs to convert old 'media' permissions to new 'file'
  // permissions, so it must run before file_entity_7208 which updates existing
  // 'file' permissions to be split per file type.
  $dependencies['file_entity'][7208] = array(
    'media' => 7200,
  );
  // This update function requires field_update_7002() to run before it since
  // the field_bundle_settings variable has been split into separate variables
  // per entity type and bundle.
  $dependencies['media'][7016] = array(
    'field' => 7002,
    'rules' => 7205,
  );
  // Those updates require {file_type} table created.
  $dependencies['media'][7204] = array(
    'file_entity' => 7201,
  );
  // Require {file_type}.mimetypes column before updating them.
  $dependencies['media'][7208] = array(
    'file_entity' => 7210,
  );
  return $dependencies;
}

/**
 * Implements hook_requirements().
 */
function media_requirements($phase) {
  $t = get_t();
  // Make sure that file_entity module is 2.x version.
  // We can't add this check in .info file because drupal.org testbot cant
  // handle it. See #1734648.
  $requirements = array();

  if ($phase == 'update') {
    $info = system_get_info('module', 'file_entity');
    if (strpos($info['version'], '7.x-2') === FALSE) {
      $requirements['file_entity'] = array(
        'title' => $t('File entity 2.x'),
        'value' => $t('Wrong version'),
        'severity' => REQUIREMENT_ERROR,
        'description' => $t('Media 2.x requires <a href="@url">File entity 2.x</a>. Please download the correct version and make sure you have deleted the file_entity folder inside the media module directory.', array('@url' => 'http://drupal.org/project/file_entity')),
      );
    }
  }

  return $requirements;
}

/**
 * Deprecated update function.
 */
function media_update_7000() {
}

/**
 * Deprecated update function.
 */
function media_update_7001() {
}

/**
 * Create the media_type table from the media_types variable.
 */
function media_update_7002() {
  $schema['media_type'] = array(
    'description' => 'Stores the settings for media types.',
    'fields' => array(
      'name' => array(
        'description' => 'The machine name of the media type.',
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
      ),
      'label' => array(
        'description' => 'The label of the media type.',
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
      ),
      'base' => array(
        'description' => 'If this is a base type (i.e. cannot be deleted)',
        'type' => 'int',
        'not null' => TRUE,
        'default' => 0,
        'size' => 'tiny',
      ),
      'weight' => array(
        'description' => 'Weight of media type. Determines which one wins when claiming a piece of media (first wins)',
        'type' => 'int',
        'not null' => TRUE,
        'default' => 0,
        'size' => 'normal',
      ),
      'type_callback' => array(
        'description' => 'Callback to determine if provided media is of this type.',
        'type' => 'varchar',
        'length' => 255,
        'not null' => FALSE,
        'default' => '',
      ),
      'type_callback_args' => array(
        'type' => 'text',
        'not null' => FALSE,
        'size' => 'big',
        'serialize' => TRUE,
        'description' => 'A serialized array of name value pairs that will be passed to the callback function',
      ),
    ),
    'primary key' => array('name'),
  );
  db_create_table('media_type', $schema['media_type']);

  drupal_load('module', 'media');
  $old_types = variable_get('media_types');
  foreach ($old_types as $type) {
    // Was an error in the original creation.
    if (isset($type->callbacks)) {
      unset($type->callbacks);
    }
    $type->name = $type->machine_name;
    unset($type->machine_name);
    db_merge('media_type')
      ->key(array('name' => $type->name))
      ->fields((array) $type)
      ->execute();
  }
  variable_del('media_types');
}

/**
 * We now prefix media namespaced variables with media__, so fix old variables.
 */
function media_update_7003() {
  drupal_load('module', 'media');
  foreach (media_variable_default() as $variable => $value) {
    if (($test = variable_get('media_' . $variable, TRUE)) == variable_get('media_' . $variable, FALSE)) {
      media_variable_set($variable, $test);
      variable_del('media_' . $variable);
    }
  }
}

/**
 * Empty update function to trigger a menu rebuild.
 */
function media_update_7004() {
}

/**
 * Deprecated update function.
 */
function media_update_7005() {
}

/**
 * Rename the file table to file_managed in case head2head was used.
 */
function media_update_7006() {
  if (db_table_exists('file') && !db_table_exists('file_managed')) {
    db_rename_table('file', 'file_managed');
  }
}

/**
 * Deprecated update function.
 */
function media_update_7007() {
}

/**
 * Empty function.
 */
function media_update_7008() {
}

/**
 * Deprecated update function.
 */
function media_update_7009() {
}

/**
 * Deprecated update function.
 */
function media_update_7010() {
}

/**
 * Empty update function.
 */
function media_update_7011() {
}

/**
 * Empty update function.
 */
function media_update_7012() {
}

/**
 * Work around a core bug where text format cacheability is not updated.
 *
 * @see http://drupal.org/node/993230
 */
function media_update_7013() {
  $formats = filter_formats();
  foreach ($formats as $format) {
    $format->filters = filter_list_format($format->format);
    // filter_format_save() expects filters to be an array, however
    // filter_list_format() gives us objects.
    foreach ($format->filters as $key => $value) {
      $format->filters[$key] = (array) $value;
    }
    filter_format_save($format);
  }
}

/**
 * Rename the media__dialog_get_theme_name variable to media__dialog_theme.
 */
function media_update_7014() {
  if ($old_value = variable_get('media__dialog_get_theme_name')) {
    variable_del('media__dialog_get_theme_name');
    variable_set('media__dialog_theme', $old_value);
  }
}

/**
 * Empty update function to trigger a registry rebuild.
 */
function media_update_7015() {
}

/**
 * Convert Media entities to File entities.
 *
 * This update function requires field_update_7002() to run before it since
 * the field_bundle_settings variable has been split into separate variables
 * per entity type and bundle.
 *
 * @see http://drupal.org/node/1418708
 * @see http://drupal.org/node/1211008
 */
function media_update_7016() {
  // Allow File Entity module to take over the {file_managed}.type field. It
  // will create new indexes as it needs to, but it doesn't know about old ones,
  // so delete them.
  if (db_index_exists('file_managed', 'file_type')) {
    db_drop_index('file_managed', 'file_type');
  }
  module_enable(array('file_entity'));

  // Move all field instances from Media entity to File entity.
  $instances = field_read_instances(array('entity_type' => 'media'), array('include_inactive' => TRUE, 'include_deleted' => TRUE));
  foreach ($instances as $instance) {
    // Skip the old self-referencing file field. It will be deleted later in
    // this function.
    if ($instance['field_name'] === 'file') {
      continue;
    }

    // @todo Convert this to use _update_7000_field_read_fields()
    $fields = field_read_fields(array('id' => $instance['field_id']), array('include_inactive' => TRUE, 'include_deleted' => TRUE));
    $field = $fields[$instance['field_id']];

    // There is no API for updating the entity_type foreign key within field
    // data storage. We can do a direct db_update() for when the default SQL
    // storage back-end is being used, but must skip updating fields that use a
    // different storage type.
    if ($field['storage']['type'] !== 'field_sql_storage' || !module_exists('field_sql_storage') || !$field['storage']['active']) {
      $messages[] = t('Cannot update field %id (%field_name) because it does not use the field_sql_storage storage type.', array(
        '%id' => $field['id'],
        '%field_name' => $field['field_name'],
      ));
      continue;
    }

    // Update the data tables.
    $table_name = _field_sql_storage_tablename($field);
    $revision_name = _field_sql_storage_revision_tablename($field);
    db_update($table_name)
      ->fields(array('entity_type' => 'file'))
      ->condition('entity_type', 'media')
      ->condition('bundle', $instance['bundle'])
      ->execute();
    db_update($revision_name)
      ->fields(array('entity_type' => 'file'))
      ->condition('entity_type', 'media')
      ->condition('bundle', $instance['bundle'])
      ->execute();

    // Once all the data has been updated, update the {field_config_instance}
    // record.
    db_update('field_config_instance')
      ->fields(array('entity_type' => 'file'))
      ->condition('id', $instance['id'])
      ->execute();
  }

  // Update the field_bundle_settings configuration variable: move media bundle
  // settings to file bundles, and move settings of the old self-referencing
  // file field to the new file pseudo-field.
  foreach ($instances as $instance) {
    if ($instance['field_name'] === 'file' && !$instance['deleted']) {
      $file_settings = field_bundle_settings('file', $instance['bundle']);
      $media_settings = field_bundle_settings('media', $instance['bundle']);
      $file_settings = array_merge($file_settings, $media_settings);
      if (isset($instance['widget']['weight'])) {
        $file_settings['extra_fields']['form']['file']['weight'] = $instance['widget']['weight'];
      }
      if (isset($instance['display'])) {
        foreach ($instance['display'] as $view_mode => $display) {
          if (isset($display['weight'])) {
            $file_settings['extra_fields']['display']['file'][$view_mode]['weight'] = $display['weight'];
          }
          if (isset($display['type'])) {
            $file_settings['extra_fields']['display']['file'][$view_mode]['visible'] = ($display['type'] != 'hidden');
          }
        }
      }
      field_bundle_settings('file', $instance['bundle'], $file_settings);
    }
  }
  // Delete old media bundle settings.
  db_delete('variable')
    ->condition('name', db_like('field_bundle_settings_media__') . '%', 'LIKE')
    ->execute();

  // Copy field formatter settings of old self-referencing file field to file
  // pseudo-field formatter settings.
  $file_displays = variable_get('file_displays', array());
  foreach ($instances as $instance) {
    if ($instance['field_name'] === 'file' && !$instance['deleted']) {
      if (isset($instance['display'])) {
        foreach ($instance['display'] as $view_mode => $display) {
          if (isset($display['type']) && $display['type'] != 'hidden') {
            $file_formatter = 'file_field_' . $display['type'];
            $file_displays[$instance['bundle']][$view_mode][$file_formatter]['status'] = TRUE;
            if (isset($display['settings'])) {
              $file_displays[$instance['bundle']][$view_mode][$file_formatter]['settings'] = $display['settings'];
            }
          }
        }
      }
    }
  }
  variable_set('file_displays', $file_displays);

  // Delete the old self-referencing file field instances. If all instances are
  // deleted, field_delete_instance() will delete the field too.
  foreach ($instances as $instance) {
    if ($instance['field_name'] === 'file' && !$instance['deleted']) {
      field_delete_instance($instance);
    }
  }

  field_cache_clear();
}

/**
 * Move file display configuration.
 *
 * Move file display configurations from the 'file_displays' variable to the
 * {file_display} table.
 */
function media_update_7017() {
  // If the {file_display} table doesn't exist, then the File Entity module's
  // update functions will automatically take care of migrating the
  // configurations. However, if file_entity_update_7001() has already run
  // prior to media_update_7016(), run it again in order to capture those
  // configurations too.
  if (db_table_exists('file_display') && function_exists('file_entity_update_7001')) {
    module_load_include('install', 'file_entity', 'file_entity');
    file_entity_update_7001();
  }
}

/**
 * Empty update function to trigger a menu rebuild.
 */
function media_update_7018() {
}

/**
 * Update old view mode formaters.
 *
 * Update old per-view-mode media field formatters to the generic media
 * formatter with a setting.
 */
function media_update_7019() {
  $instances = array();
  $fields = field_read_fields(array('type' => 'media'), array('include_inactive' => TRUE));
  foreach ($fields as $field) {
    $instances = array_merge($instances, field_read_instances(array('field_id' => $field['id']), array('include_inactive' => TRUE)));
  }
  foreach ($instances as $instance) {
    $update_instance = FALSE;
    foreach ($instance['display'] as $view_mode => $display) {
      if (in_array($display['type'], array('media_link', 'media_preview', 'media_small', 'media_large', 'media_original'))) {
        $update_instance = TRUE;
        $instance['display'][$view_mode]['type'] = 'media';
        $instance['display'][$view_mode]['settings'] = array('file_view_mode' => $display['type']);
      }
    }
    if ($update_instance) {
      field_update_instance($instance);
    }
  }
}

/**
 * Delete the wysiwyg_allowed_types variable if it is the same as default.
 */
function media_update_7020() {
  if (variable_get('media__wysiwyg_allowed_types') == array('image', 'video')) {
    variable_del('media__wysiwyg_allowed_types');
  }
}

/**
 * Replace 'view media' perm from all users having the role with 'view file'.
 */
function media_update_7200() {
  $perms = user_permission_get_modules();
  if (!isset($perms['view files'])) {
    throw new DrupalUpdateException('The File Entity module needs to be upgraded before continuing.');
  }
  else {
    $roles = user_roles(FALSE, 'view media');
    $permissions = array(
      'view media' => FALSE,
      'view files' => TRUE,
    );
    foreach ($roles as $rid => $role) {
      user_role_change_permissions($rid, $permissions);
    }
    $roles = user_roles(FALSE, 'edit media');
    $permissions = array(
      'edit media' => FALSE,
      'edit any files' => TRUE,
    );
    if (function_exists('file_entity_list_permissions')) {
      unset($permissions['edit any files']);

      foreach (file_entity_permissions_get_configured_types() as $type) {
        $permissions += file_entity_list_permissions($type);
      }
    }
    foreach ($roles as $rid => $role) {
      user_role_change_permissions($rid, $permissions);
    }
    $roles = user_roles(FALSE, 'administer media');
    $permissions = array(
      'administer media' => FALSE,
      'administer files' => TRUE,
    );
    foreach ($roles as $rid => $role) {
      user_role_change_permissions($rid, $permissions);
    }
  }
}

/**
 * Handle existing media fields.
 *
 * Enable the new Media Field module if this site uses "media" fields. File
 * fields are now preferred for storing media.
 */
function media_update_7201() {
  $fields = field_info_fields();
  foreach ($fields as $field) {
    if ($field['type'] == 'media') {
      // This update function may run even if Media is not enabled. Don't enable
      // Media Field if its dependencies aren't already enabled.
      module_enable(array('mediafield'), FALSE);

      // Update entries in file_usage so that they are associated with Media
      // Field rather than Media.
      // @TODO This update function may conflict with
      // http://drupal.org/node/1268116
      db_update('file_usage')
        ->condition('module', 'media')
        ->fields(array('module' => 'mediafield'))
        ->execute();

      return t('The "Media" field type has been moved to the new "Media Field" module. This site uses media fields, so the Media Field module has been enabled.');
    }
  }
  return t('The "Media" field type has been moved to the new "Media Field" module. File fields can be used to store media.');
}

/**
 * Enable the Views module if it is not already enabled.
 */
function media_update_7202() {
  module_enable(array('views'));
  if (!module_exists('views')) {
    throw new DrupalUpdateException('The <a href="https://drupal.org/project/views">Views module</a> must be downloaded and available for Media updates to proceed.');
  }
}

/**
 * Empty update function to trigger cache clear.
 */
function media_update_7203() {
  // Do nothing.
}

/**
 * Update old Media view modes to the new File Entity ones.
 */
function media_update_7204() {
  $view_mode_updates = array(
    'media_preview' => 'preview',
    'media_small' => 'teaser',
    'media_large' => 'full',
  );

  // Update the media__wysiwyg_default_view_mode variable.
  $wysiwyg_default_view_mode = variable_get('media__wysiwyg_default_view_mode');
  if (isset($wysiwyg_default_view_mode) && isset($view_mode_updates[$wysiwyg_default_view_mode])) {
    $wysiwyg_default_view_mode = $view_mode_updates[$wysiwyg_default_view_mode];
    variable_set('media__wysiwyg_default_view_mode', $wysiwyg_default_view_mode);
  }

  // Update view mode references in the 'field_bundle_settings' variable.
  $field_bundle_settings = variable_get('field_bundle_settings');
  if (!empty($field_bundle_settings['file'])) {
    foreach ($field_bundle_settings['file'] as $file_type => $info) {
      // Per-bundle information about the view modes.
      foreach ($view_mode_updates as $old_view_mode => $new_view_mode) {
        if (isset($info['view_modes'][$old_view_mode])) {
          $field_bundle_settings['file'][$file_type]['view_modes'][$new_view_mode] = $info['view_modes'][$old_view_mode];
          unset($field_bundle_settings['file'][$file_type]['view_modes'][$old_view_mode]);
        }
        // The File Entity module defaults to not use custom settings for the
        // new view modes, but the Media module used to default to using custom
        // settings, so if this variable is not defined, use the prior default.
        if (!isset($field_bundle_settings['file'][$file_type]['view_modes'][$new_view_mode]['custom_settings'])) {
          $field_bundle_settings['file'][$file_type]['view_modes'][$new_view_mode]['custom_settings'] = TRUE;
        }
      }

      // Settings for the "extra fields" configured on the Manage Display page.
      if (!empty($info['extra_fields']['display'])) {
        foreach ($info['extra_fields']['display'] as $extra_field_name => $extra_field_info) {
          foreach ($view_mode_updates as $old_view_mode => $new_view_mode) {
            if (isset($extra_field_info[$old_view_mode])) {
              $field_bundle_settings['file'][$file_type]['extra_fields']['display'][$extra_field_name][$new_view_mode] = $extra_field_info[$old_view_mode];
              unset($field_bundle_settings['file'][$file_type]['extra_fields']['display'][$extra_field_name][$old_view_mode]);
            }
          }
        }
      }
    }
  }
  variable_set('field_bundle_settings', $field_bundle_settings);

  // Move settings for fields attached to files from the old view modes to the
  // new ones.
  $instances = field_read_instances(array('entity_type' => 'file'));
  foreach ($instances as $instance) {
    $updated = FALSE;
    foreach ($view_mode_updates as $old_view_mode => $new_view_mode) {
      if (isset($instance['display'][$old_view_mode])) {
        $instance['display'][$new_view_mode] = $instance['display'][$old_view_mode];
        unset($instance['display'][$old_view_mode]);
        $updated = TRUE;
      }
    }
    if ($updated) {
      field_update_instance($instance);
    }
  }

  // Move "Manage file display" settings from old view modes to new ones.
  $file_display_names = db_query('SELECT name FROM {file_display}')->fetchCol();
  foreach ($file_display_names as $old_file_display_name) {
    list($file_type, $view_mode, $formatter) = explode('__', $old_file_display_name, 3);
    if (isset($view_mode_updates[$view_mode])) {
      $view_mode = $view_mode_updates[$view_mode];
      $new_file_display_name = implode('__', array($file_type, $view_mode, $formatter));
      db_delete('file_display')->condition('name', $new_file_display_name)->execute();
      db_update('file_display')->fields(array('name' => $new_file_display_name))->condition('name', $old_file_display_name)->execute();
    }
  }

  // Update file/image/media fields that use a formatter that reference an old
  // file view modes to reference the new ones.
  foreach (field_read_instances() as $instance) {
    if (!empty($instance['display'])) {
      $updated = FALSE;
      foreach ($instance['display'] as $instance_view_mode => $display) {
        if (isset($display['settings']['file_view_mode']) && isset($view_mode_updates[$display['settings']['file_view_mode']])) {
          $instance['display'][$instance_view_mode]['settings']['file_view_mode'] = $view_mode_updates[$display['settings']['file_view_mode']];
          $updated = TRUE;
        }
      }
      if ($updated) {
        field_update_instance($instance);
      }
    }
  }

  // Update formatter settings that reference the old view modes within saved
  // Views.
  if (db_table_exists('views_display')) {
    $result = db_select('views_display', 'v')->fields('v', array('vid', 'id', 'display_options'))->execute();
    foreach ($result as $record) {
      if (!empty($record->display_options)) {
        $display_options = unserialize($record->display_options);
        if (_media_update_7204_update_views_display_options($display_options, $view_mode_updates)) {
          db_update('views_display')
            ->fields(array('display_options' => serialize($display_options)))
            ->condition('vid', $record->vid)
            ->condition('id', $record->id)
            ->execute();
        }
      }
    }
  }

  // Update formatter settings that reference the old view modes within unsaved
  // Views in the CTools object cache. Objects in the CTools cache are instances
  // of classes, so the Views module must be enabled to unserialize it
  // correctly.
  if (db_table_exists('ctools_object_cache') && module_exists('views')) {
    $result = db_select('ctools_object_cache', 'c')->fields('c', array('sid', 'name', 'obj', 'data'))->condition('obj', 'view')->execute();
    foreach ($result as $record) {
      $view = unserialize($record->data);
      if (!empty($view->display)) {
        $updated = FALSE;
        foreach ($view->display as $display_name => $display) {
          if (!empty($display->display_options) && _media_update_7204_update_views_display_options($display->display_options, $view_mode_updates)) {
            $updated = TRUE;
          }
        }
        if ($updated) {
          db_update('ctools_object_cache')
            ->fields(array('data' => serialize($view)))
            ->condition('sid', $record->sid)
            ->condition('name', $record->name)
            ->condition('obj', $record->obj)
            ->execute();
        }
      }
    }
  }

  // Clear caches that might contain stale Views displays.
  if (module_exists('views')) {
    cache_clear_all('*', 'cache_views', TRUE);
    cache_clear_all('*', 'cache_views_data', TRUE);
  }
  if (module_exists('block')) {
    cache_clear_all('*', 'cache_block', TRUE);
  }
  cache_clear_all('*', 'cache_page', TRUE);

  // We still have the old media_link and media_original view modes that must be
  // supported for now.
  // @TODO: Make this apply only to updates from Media 1.x.
  // @see media_entity_info_alter()
  variable_set('media__show_deprecated_view_modes', TRUE);
}

/**
 * Drop the unused {media_list_type} table.
 */
function media_update_7205() {
  if (db_table_exists('media_list_type')) {
    db_drop_table('media_list_type');
    return t('Dropped the unused {media_list_type} table.');
  }
}

/**
 * Move default file display configurations to the database.
 */
function media_update_7206() {
  module_load_include('inc', 'file_entity', 'file_entity.file_api');
  module_load_include('inc', 'ctools', 'includes/export');
  $default_image_styles = array(
    'preview' => 'square_thumbnail',
    'teaser' => 'medium',
    'full' => 'large',
  );

  // Only needed by sites that updated from Media 1.x.
  // @see media_entity_info_alter()
  if (variable_get('media__show_deprecated_view_modes')) {
    $default_image_styles['media_original'] = '';
  }

  // Clear out the ctools cache so that the old default implementations
  // are removed.
  ctools_export_load_object_reset('file_display');
  foreach ($default_image_styles as $view_mode => $image_style) {
    $existing_displays = file_displays_load('image', $view_mode, TRUE);
    // Only insert default config into the database if no existing
    // configuration is found.
    if (!isset($existing_displays['file_image'])) {
      $display_name = 'image__' . $view_mode . '__file_image';
      $display = array(
        'api_version' => 1,
        'name' => $display_name,
        'status' => 1,
        'weight' => 5,
        'settings' => array('image_style' => $image_style),
        'export_type' => NULL,
      );
      file_display_save((object) $display);
    }
  }
}

/**
 * Trigger cache clear.
 *
 * Empty update function to trigger cache clear after changing access callbacks
 * to file_entity_access.
 */
function media_update_7207() {
  // Do nothing.
}

/**
 * Drop the media_types table and migrate files to file_entity types.
 */
function media_update_7208() {
  // Reset static cache to ensure our new file types are recognized
  drupal_static_reset('ctools_export_load_object_table_exists');

  if (!db_table_exists('media_type')) {
    // No types to migrate.
    return;
  }
  // @see http://drupal.org/node/1292382
  if (!function_exists('file_type_get_enabled_types')) {
    throw new DrupalUpdateException('The File Entity module needs to be upgraded before continuing.');
  }
  else {
    $existing_types = db_select('media_type', 'mt')
      ->orderBy('weight')
      ->fields('mt')
      ->execute()
      // Will key by the name field.
      ->fetchAllAssoc('name');
    foreach ($existing_types as &$type) {
      $type->type_callback_args = unserialize($type->type_callback_args);
    }

    include_once DRUPAL_ROOT . '/includes/file.mimetypes.inc';
    $mapping = file_mimetype_mapping();
    // We do not migrate this type, since there is no way to handle its weight.
    unset($existing_types['default']);
    foreach ($existing_types as $type) {
      $extensions = isset($type->type_callback_args['extensions']) ? $type->type_callback_args['extensions'] : array();
      $mimetypes = isset($type->type_callback_args['mimetypes']) ? $type->type_callback_args['mimetypes'] : array();
      // Add mimetypes by extensions.
      foreach ($extensions as $extension) {
        if (isset($mapping['extensions'][$extension])) {
          $type->mimetypes[] = $mapping['mimetypes'][$mapping['extensions'][$extension]];
        }
      }
      // Add rest mimetypes.
      foreach ($mimetypes as $mimetype) {
        // Mimetype is a regex pattern.
        foreach ($mapping['mimetypes'] as $mapping_mimetype) {
          if (preg_match($mimetype, $mapping_mimetype) && !in_array($mapping_mimetype, $type->mimetypes)) {
            $type->mimetypes[] = $mapping_mimetype;
          }
        }
      }
      $type->streams = isset($type->type_callback_args['streams']) ? $type->type_callback_args['streams'] : array();
      $type->type = $type->name;
      // Merge existing type with new ones.
      if ($new_type = file_type_load($type->name)) {
        $new_type->mimetypes = array_merge($type->mimetypes, $new_type->mimetypes);
        $new_type->streams = array_merge($type->streams, $new_type->streams);
      }
      else {
        $new_type = $type;
      }
      file_type_save($new_type);
    }
    db_drop_table('media_type');

    // Special treatment for old media application type to new file_entity
    // document one. Add some more mimetypes to document.
    $document_type = file_type_load('document');
    if (!$document_type) {
      return;
    }
    foreach ($mapping['mimetypes'] as $mimetype) {
      $is_document = strpos($mimetype, 'document') !== FALSE || strpos($mimetype, 'application/vnd.ms-') !== FALSE;
      if ($is_document && !in_array($mimetype, $document_type->mimetypes)) {
        $document_type->mimetypes[] = $mimetype;
      }
    }
    file_type_save($document_type);
  }
}

/**
 * DEPRECATED: Update {file_managed}.type with the new file types provided by
 * file_entity. (Types migration has been moved to admin/structure/file-types/upgrade',
 * where can be executed manually.)
 */
function media_update_7209() {

}

/**
 * Delete deceprated media__type_icon_directory variable.
 */
function media_update_7210() {
  variable_del('media__type_icon_directory');
}

/**
 * Flush old version of the image style to make the thumbnails appear correctly.
 */
function media_update_7211() {
  $style = image_style_load('square_thumbnail');

  if ($style) {
    $style['name'] = 'media_thumbnail';
    image_style_save($style);
  }

  // Replace any instances in display settings
  module_load_include('inc', 'file_entity', 'file_entity.file_api');
  $entity_info = entity_get_info('file');
  $view_modes = array('default' => array('label' => t('Default'))) + $entity_info['view modes'];
  foreach ($view_modes as $view_mode => $view_mode_info) {
    $displays = file_displays_load('image', $view_mode);
    foreach ($displays as $display) {
      if ($display->settings['image_style'] == 'square_thumbnail') {
        $display->settings['image_style'] = 'media_thumbnail';
        file_display_save($display);
      }
    }
  }

  return t('Flushed image style and updated display styles.');
}

/**
 * Utility function for update 7204. Updates display options within Views.
 */
function _media_update_7204_update_views_display_options(&$display_options, $view_mode_updates) {
  $updated = FALSE;

  // Update fields that use a formatter with a file_view_mode formatter setting.
  if (!empty($display_options['fields'])) {
    foreach ($display_options['fields'] as $field_name => $field_display) {
      if (isset($field_display['settings']['file_view_mode']) && isset($view_mode_updates[$field_display['settings']['file_view_mode']])) {
        $display_options['fields'][$field_name]['settings']['file_view_mode'] = $view_mode_updates[$field_display['settings']['file_view_mode']];
        $updated = TRUE;
      }
    }
  }

  // Update Views that display files directly using a row plugin with a view
  // mode setting.
  if (isset($display_options['row_plugin']) && $display_options['row_plugin'] === 'file' && isset($display_options['row_options']['view_mode']) && isset($view_mode_updates[$display_options['row_options']['view_mode']])) {
    $display_options['row_options']['view_mode'] = $view_mode_updates[$display_options['row_options']['view_mode']];
    $updated = TRUE;
  }
  return $updated;
}

/**
 * Re-create application file type for legacy reasons.
 */
function media_update_7212() {
  module_load_include('inc', 'file_entity', 'file_entity.file_api');
  if (!file_type_load('application')) {
    $application = (object) array(
      'api_version' => 1,
      'type' => 'application',
      'label' => t('Application'),
      'description' => t('Multipurpose type - kept to support older sites.'),
      'mimetypes' => array(),
      'streams' => array(
        'public',
      ),
    );

    file_type_save($application);
    $application = file_type_load('application');
    file_type_disable($application);
  }
}

/**
 * Remove the obsolete file_extensions variable.
 */
function media_update_7213() {
  $media_file_extensions = explode(' ', variable_get('media__file_extensions'));
  $file_entity_file_extensions = explode(' ', variable_get('file_entity_default_allowed_extensions', 'jpg jpeg gif png txt doc docx xls xlsx pdf ppt pptx pps ppsx odt ods odp mp3 mov mp4 m4a m4v mpeg avi ogg oga ogv weba webp webm'));

  // Preserve any custom file extensions.
  if (array_diff($media_file_extensions, $file_entity_file_extensions)) {
    $combined_file_extensions = array_unique(array_merge($file_entity_file_extensions, $media_file_extensions));
    variable_set('file_entity_default_allowed_extensions', implode(' ' , $combined_file_extensions));
  }

  variable_del('media__file_extensions');
}

/**
 * Drop the legacy {media_filter_usage} table.
 */
function media_update_7214() {
  if (db_table_exists('media_filter_usage')) {
    db_drop_table('media_filter_usage');
  }
}

/**
 * Skipped to run media_update_7217().
 */
function media_update_7216() {
  // Do nothing.
}

/**
 * Copy file type icons to public files directory.
 */
function media_update_7217() {
  // Remove any trailing slashes from the icon base directory variable.
  $dir = variable_get('media__icon_base_directory');
  if (!empty($dir)) {
    $dir = rtrim($dir, '/');
    variable_set('media__icon_base_directory', $dir);
  }

  try {
    _media_install_copy_icons();
  }
  catch (Exception $e) {
    throw new DrupalUpdateException($e->getMessage());
  }
}

/**
 * Drop the legacy {cache_media_xml} table.
 */
function media_update_7218() {
  if (db_table_exists('cache_media_xml')) {
    db_drop_table('cache_media_xml');
  }

  variable_del('media__xml_cache_expire');
}