<?php

/**
 * Default number of items indexed per cron batch for each enabled index.
 */
define('SEARCH_API_DEFAULT_CRON_LIMIT', 50);

/**
 * Implements hook_menu().
 */
function search_api_menu() {
  $pre = 'admin/config/search/search_api';
  $items[$pre] = array(
    'title' => 'Search API',
    'description' => 'Create and configure search engines.',
    'page callback' => 'search_api_admin_overview',
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
  );
  $items[$pre . '/overview'] = array(
    'title' => 'Overview',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  );
  $items[$pre . '/add_server'] = array(
    'title' => 'Add server',
    'description' => 'Create a new search server.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_add_server'),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
    'weight' => -1,
    'type' => MENU_LOCAL_ACTION,
  );
  $items[$pre . '/add_index'] = array(
    'title' => 'Add index',
    'description' => 'Create a new search index.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_add_index'),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
    'type' => MENU_LOCAL_ACTION,
  );
  $items[$pre . '/server/%search_api_server'] = array(
    'title' => 'View server',
    'title callback' => 'search_api_admin_item_title',
    'title arguments' => array(5),
    'description' => 'View server details.',
    'page callback' => 'search_api_admin_server_view',
    'page arguments' => array(5),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
  );
  $items[$pre . '/server/%search_api_server/view'] = array(
    'title' => 'View',
    'weight' => -10,
    'type' => MENU_DEFAULT_LOCAL_TASK,
  );
  $items[$pre . '/server/%search_api_server/edit'] = array(
    'title' => 'Edit',
    'description' => 'Edit server details.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_server_edit', 5),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
    'weight' => -1,
    'type' => MENU_LOCAL_TASK,
  );
  $items[$pre . '/server/%search_api_server/delete'] = array(
    'title' => 'Delete',
    'title callback' => 'search_api_title_delete_page',
    'title arguments' => array(5),
    'description' => 'Delete server.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_confirm', 'server', 'delete', 5),
    'access callback' => 'search_api_access_delete_page',
    'access arguments' => array(5),
    'file' => 'search_api.admin.inc',
    'type' => MENU_LOCAL_TASK,
  );
  $items[$pre . '/index/%search_api_index'] = array(
    'title' => 'View index',
    'title callback' => 'search_api_admin_item_title',
    'title arguments' => array(5),
    'description' => 'View index details.',
    'page callback' => 'search_api_admin_index_view',
    'page arguments' => array(5),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
  );
  $items[$pre . '/index/%search_api_index/view'] = array(
    'title' => 'View',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  );
  $items[$pre . '/index/%search_api_index/status'] = array(
    'title' => 'Status',
    'description' => 'Display and work on index status.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_index_status_form', 5),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
    'weight' => -8,
    'type' => MENU_LOCAL_TASK,
    'context' => MENU_CONTEXT_INLINE | MENU_CONTEXT_PAGE,
  );
  $items[$pre . '/index/%search_api_index/edit'] = array(
    'title' => 'Settings',
    'description' => 'Edit index settings.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_index_edit', 5),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
    'weight' => -6,
    'type' => MENU_LOCAL_TASK,
    'context' => MENU_CONTEXT_INLINE | MENU_CONTEXT_PAGE,
  );
  $items[$pre . '/index/%search_api_index/fields'] = array(
    'title' => 'Fields',
    'description' => 'Select indexed fields.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_index_fields', 5),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
    'weight' => -4,
    'type' => MENU_LOCAL_TASK,
    'context' => MENU_CONTEXT_INLINE | MENU_CONTEXT_PAGE,
  );
  $items[$pre . '/index/%search_api_index/workflow'] = array(
    'title' => 'Workflow',
    'description' => 'Edit index workflow.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_index_workflow', 5),
    'access arguments' => array('administer search_api'),
    'file' => 'search_api.admin.inc',
    'weight' => -2,
    'type' => MENU_LOCAL_TASK,
    'context' => MENU_CONTEXT_INLINE | MENU_CONTEXT_PAGE,
  );
  $items[$pre . '/index/%search_api_index/delete'] = array(
    'title' => 'Delete',
    'title callback' => 'search_api_title_delete_page',
    'title arguments' => array(5),
    'description' => 'Delete index.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('search_api_admin_confirm', 'index', 'delete', 5),
    'access callback' => 'search_api_access_delete_page',
    'access arguments' => array(5),
    'file' => 'search_api.admin.inc',
    'type' => MENU_LOCAL_TASK,
  );

  return $items;
}

/**
 * Implements hook_theme().
 */
function search_api_theme() {
  $themes['search_api_server'] = array(
    'variables' => array(
      'id' => NULL,
      'name' => '',
      'machine_name' => '',
      'description' => NULL,
      'enabled' => NULL,
      'class_name' => NULL,
      'class_description' => NULL,
      'options' => array(),
      'status' => ENTITY_CUSTOM,
    ),
    'file' => 'search_api.admin.inc',
  );
  $themes['search_api_index'] = array(
    'variables' => array(
      'id' => NULL,
      'name' => '',
      'machine_name' => '',
      'description' => NULL,
      'item_type' => NULL,
      'enabled' => NULL,
      'server' => NULL,
      'options' => array(),
      'fields' => array(),
      'indexed_items' => 0,
      'total_items' => 0,
      'status' => ENTITY_CUSTOM,
      'read_only' => 0,
    ),
    'file' => 'search_api.admin.inc',
  );
  $themes['search_api_admin_item_order'] = array(
    'render element' => 'element',
    'file' => 'search_api.admin.inc',
  );
  $themes['search_api_admin_fields_table'] = array(
    'render element' => 'element',
    'file' => 'search_api.admin.inc',
  );

  return $themes;
}

/**
 * Implements hook_permission().
 */
function search_api_permission() {
  return array(
    'administer search_api' => array(
      'title' => t('Administer Search API'),
      'description' => t('Create and configure Search API servers and indexes.'),
    ),
  );
}

/**
 * Implements hook_cron().
 *
 * Will index $options['cron-limit'] items for each enabled index.
 */
function search_api_cron() {
  $queue = DrupalQueue::get('search_api_indexing_queue');
  foreach (search_api_index_load_multiple(FALSE, array('enabled' => TRUE, 'read_only' => 0)) as $index) {
    $limit = isset($index->options['cron_limit'])
        ? $index->options['cron_limit']
        : SEARCH_API_DEFAULT_CRON_LIMIT;
    if ($limit) {
      try {
        $task = array('index' => $index->machine_name);
        $ids = search_api_get_items_to_index($index, -1);
        if (!$ids) {
          continue;
        }
        $batches = $limit > 0 ? array_chunk($ids, $limit, TRUE) : array($ids);
        foreach ($batches as $batch) {
          $task['items'] = $batch;
          $queue->createItem($task);
        }
        // Mark items as queued so they won't be inserted into the queue again
        // on the next cron run.
        search_api_track_item_queued($index, $ids);
      }
      catch (SearchApiException $e) {
        watchdog_exception('search_api', $e);
      }
    }
  }
}

/**
 * Implements hook_cron_queue_info().
 *
 * Defines a queue for saved searches that should be checked for new items.
 */
function search_api_cron_queue_info() {
  return array(
    'search_api_indexing_queue' => array(
      'worker callback' => '_search_api_indexing_queue_process',
      'time' => variable_get('search_api_index_worker_callback_runtime', 15),
    ),
  );
}

/**
 * Implements hook_entity_info().
 */
function search_api_entity_info() {
  $info['search_api_server'] = array(
    'label' => t('Search server'),
    'controller class' => 'EntityAPIControllerExportable',
    'metadata controller class' => FALSE,
    'entity class' => 'SearchApiServer',
    'base table' => 'search_api_server',
    'uri callback' => 'search_api_server_url',
    'module' => 'search_api',
    'exportable' => TRUE,
    'entity keys' => array(
      'id' => 'id',
      'label' => 'name',
      'name' => 'machine_name',
    ),
  );
  $info['search_api_index'] = array(
    'label' => t('Search index'),
    'controller class' => 'EntityAPIControllerExportable',
    'metadata controller class' => FALSE,
    'entity class' => 'SearchApiIndex',
    'base table' => 'search_api_index',
    'uri callback' => 'search_api_index_url',
    'module' => 'search_api',
    'exportable' => TRUE,
    'entity keys' => array(
      'id' => 'id',
      'label' => 'name',
      'name' => 'machine_name',
    ),
  );

  return $info;
}

/**
 * Implements hook_entity_property_info().
 */
function search_api_entity_property_info() {
  $info['search_api_server']['properties'] = array(
    'id' => array(
      'label' => t('ID'),
      'type' => 'integer',
      'description' => t('The primary identifier for a server.'),
      'schema field' => 'id',
      'validation callback' => 'entity_metadata_validate_integer_positive',
    ),
    'name' => array(
      'label' => t('Name'),
      'type' => 'text',
      'description' => t('The displayed name for a server.'),
      'schema field' => 'name',
      'required' => TRUE,
    ),
    'machine_name' => array(
      'label' => t('Machine name'),
      'type' => 'token',
      'description' => t('The internally used machine name for a server.'),
      'schema field' => 'machine_name',
      'required' => TRUE,
    ),
    'description' => array(
      'label' => t('Description'),
      'type' => 'text',
      'description' => t('The displayed description for a server.'),
      'schema field' => 'description',
      'sanitize' => 'filter_xss',
    ),
    'class' => array(
      'label' => t('Service class'),
      'type' => 'text',
      'description' => t('The ID of the service class to use for this server.'),
      'schema field' => 'class',
      'required' => TRUE,
    ),
    'enabled' => array(
      'label' => t('Enabled'),
      'type' => 'boolean',
      'description' => t('A flag indicating whether the server is enabled.'),
      'schema field' => 'enabled',
    ),
  );
  $info['search_api_index']['properties'] = array(
    'id' => array(
      'label' => t('ID'),
      'type' => 'integer',
      'description' => t('An integer identifying the index.'),
      'schema field' => 'id',
      'validation callback' => 'entity_metadata_validate_integer_positive',
    ),
    'name' => array(
      'label' => t('Name'),
      'type' => 'text',
      'description' => t('A name to be displayed for the index.'),
      'schema field' => 'name',
      'required' => TRUE,
    ),
    'machine_name' => array(
      'label' => t('Machine name'),
      'type' => 'token',
      'description' => t('The internally used machine name for an index.'),
      'schema field' => 'machine_name',
      'required' => TRUE,
    ),
    'description' => array(
      'label' => t('Description'),
      'type' => 'text',
      'description' => t("A string describing the index' use to users."),
      'schema field' => 'description',
      'sanitize' => 'filter_xss',
    ),
    'server' => array(
      'label' => t('Server ID'),
      'type' => 'token',
      'description' => t('The machine name of the search_api_server with which data should be indexed.'),
      'schema field' => 'server',
    ),
    'server_entity' => array(
      'label' => t('Server'),
      'type' => 'search_api_server',
      'description' => t('The search_api_server with which data should be indexed.'),
      'getter callback' => 'search_api_index_get_server',
    ),
    'item_type' => array(
      'label' => t('Item type'),
      'type' => 'token',
      'description' => t('The type of items stored in this index.'),
      'schema field' => 'item_type',
      'required' => TRUE,
    ),
    'enabled' => array(
      'label' => t('Enabled'),
      'type' => 'boolean',
      'description' => t('A flag indicating whether the index is enabled.'),
      'schema field' => 'enabled',
    ),
    'read_only' => array(
      'label' => t('Read only'),
      'type' => 'boolean',
      'description' => t('A flag indicating whether the index is read-only.'),
      'schema field' => 'read_only',
    ),
  );

  return $info;
}

/**
 * Implements hook_search_api_server_insert().
 *
 * Calls the postCreate() method for the server.
 */
function search_api_search_api_server_insert(SearchApiServer $server) {
  $server->postCreate();
}

/**
 * Implements hook_search_api_server_update().
 *
 * Calls the server's postUpdate() method and marks all of this server's indexes
 * for reindexing, if necessary.
 */
function search_api_search_api_server_update(SearchApiServer $server) {
  if ($server->postUpdate()) {
    foreach (search_api_index_load_multiple(FALSE, array('server' => $server->machine_name)) as $index) {
      $index->reindex();
    }
  }
  if ($server->enabled != $server->original->enabled) {
    if ($server->enabled) {
      // Were there any changes in the server's indexes while it was disabled?
      $tasks = variable_get('search_api_tasks', array());
      if (isset($tasks[$server->machine_name])) {
        foreach ($tasks[$server->machine_name] as $index_id => $index_tasks) {
          $index = search_api_index_load($index_id);
          foreach ($index_tasks as $task) {
            switch ($task) {
              case 'add':
                $server->addIndex($index);
                break;
              case 'clear':
                $server->deleteItems('all', $index);
                break;
              case 'clear all':
                // Would normally be used with a fake index ID of "", since it doesn't matter.
                $server->deleteItems('all');
                break;
              case 'fields':
                if ($server->fieldsUpdated($index)) {
                  _search_api_index_reindex($index);
                }
                break;
              case 'remove':
                $server->removeIndex($index ? $index : $index_id);
                break;
              default:
                if (substr($task, 0, 7) == 'delete-') {
                  $id = substr($task, 7);
                  $server->deleteItems(array($id), $index);
                }
                else {
                  watchdog('search_api', t('Unknown task "@task" for server "@name".', array('@task' => $task, '@name' => $server->machine_name)), NULL, WATCHDOG_WARNING);
                }
            }
          }
        }
        unset($tasks[$server->machine_name]);
        variable_set('search_api_tasks', $tasks);
      }
    }
    else {
      foreach (search_api_index_load_multiple(FALSE, array('server' => $server->machine_name, 'enabled' => 1)) as $index) {
        $index->update(array('enabled' => 0));
      }
    }
  }
}

/**
 * Implements hook_search_api_server_delete().
 *
 * Calls the preDelete() method for the server.
 */
function search_api_search_api_server_delete(SearchApiServer $server) {
  $server->preDelete();


  // Only react on real delete, not revert.
  if (!$server->hasStatus(ENTITY_IN_CODE)) {
    foreach (search_api_index_load_multiple(FALSE, array('server' => $server->machine_name)) as $index) {
      $index->update(array('server' => NULL, 'enabled' => FALSE));
    }
  }

  $tasks = variable_get('search_api_tasks', array());
  unset($tasks[$server->machine_name]);
  variable_set('search_api_tasks', $tasks);
}

/**
 * Implements hook_search_api_index_insert().
 *
 * Adds the index to its server (if any) and starts tracking indexed items (if
 * the index is enabled).
 */
function search_api_search_api_index_insert(SearchApiIndex $index) {
  $index->postCreate();
}

/**
 * Implements hook_search_api_index_update().
 */
function search_api_search_api_index_update(SearchApiIndex $index) {
  // If the server was changed, we have to call the appropriate service class
  // hook methods.
  if ($index->server != $index->original->server) {
    // Server changed - inform old and new ones.
    if ($index->original->server) {
      $old_server = search_api_server_load($index->original->server);
      // The server might have changed because the old one was deleted:
      if ($old_server) {
        if ($old_server->enabled) {
          $old_server->removeIndex($index);
        }
        else {
          $tasks = variable_get('search_api_tasks', array());
          // When we add or remove an index, we can ignore all other tasks.
          $tasks[$old_server->machine_name][$index->machine_name] = array('remove');
          variable_set('search_api_tasks', $tasks);
        }
      }
    }

    if ($index->server) {
      $new_server = $index->server(TRUE);
      // If the server is enabled, we call addIndex(); otherwise, we save the task.
      if ($new_server->enabled) {
        $new_server->addIndex($index);
      }
      else {
        $tasks = variable_get('search_api_tasks', array());
        // When we add or remove an index, we can ignore all other tasks.
        $tasks[$new_server->machine_name][$index->machine_name] = array('add');
        variable_set('search_api_tasks', $tasks);
        unset($new_server);
      }
    }

    // We also have to re-index all content
    _search_api_index_reindex($index);
  }

  // If the fields were changed, call the appropriate service class hook method
  // and re-index the content, if necessary.
  $old_fields = $index->original->options + array('fields' => array());
  $old_fields = $old_fields['fields'];
  $new_fields = $index->options + array('fields' => array());
  $new_fields = $new_fields['fields'];
  if ($old_fields != $new_fields) {
    if ($index->server && $index->server()->fieldsUpdated($index)) {
      _search_api_index_reindex($index);
    }
  }

  // If the index's enabled or read-only status is being changed, queue or
  // dequeue items for indexing.
  if (!$index->read_only && $index->enabled != $index->original->enabled) {
    if ($index->enabled) {
      $index->queueItems();
    }
    else {
      $index->dequeueItems();
    }
  }
  elseif ($index->read_only != $index->original->read_only) {
    if ($index->read_only) {
      $index->dequeueItems();
    }
    else {
      $index->queueItems();
    }
  }

  // If the cron batch size changed, empty the cron queue for this index.
  $old_cron = $index->original->options + array('cron_limit' => NULL);
  $old_cron = $old_cron['cron_limit'];
  $new_cron = $index->options + array('cron_limit' => NULL);
  $new_cron = $new_cron['cron_limit'];
  if ($old_cron !== $new_cron) {
    _search_api_empty_cron_queue($index, TRUE);
  }
}

/**
 * Implements hook_search_api_index_delete().
 *
 * Removes all data for indexes not available any more.
 */
function search_api_search_api_index_delete(SearchApiIndex $index) {
  $index->postDelete();
}

/**
 * Implements hook_features_export_alter().
 *
 * Adds dependency information for exported servers.
 */
function search_api_features_export_alter(&$export, $module_name) {
  if (isset($export['features']['search_api_server'])) {
    // Get a list of the modules that provide storage engines.
    $hook = 'search_api_service_info';
    $classes = array();
    foreach (module_implements('search_api_service_info') as $module) {
      $function = $module . '_' . $hook;
      $engines = $function();
      foreach ($engines as $service => $specs) {
        $classes[$service] = $module;
      }
    }

    // Check all of the exported server specifications.
    foreach ($export['features']['search_api_server'] as $server_name) {
      // Load the server's object.
      $server = search_api_server_load($server_name);
      $module = $classes[$server->class];

      // Ensure that the module responsible for the server object is listed as
      // a dependency.
      if (!isset($export['dependencies'][$module])) {
        $export['dependencies'][$module] = $module;
      }
    }

    // Ensure the dependencies list is still sorted alphabetically.
    ksort($export['dependencies']);
  }
}

/**
 * Implements hook_entity_insert().
 *
 * Marks the new item as to-index for all indexes on entities of the specified
 * type.
 *
 * @param $entity
 *   The new entity.
 * @param $type
 *   The entity's type.
 */
function search_api_entity_insert($entity, $type) {
  // When inserting a new search index, the new index was already inserted into
  // the tracking table. This would lead to a duplicate-key issue, if we would
  // continue.
  // We also only react on entity operations for types with property
  // information, as we don't provide search integration for the others.
  if ($type == 'search_api_index' || !entity_get_property_info($type)) {
    return;
  }
  list($id) = entity_extract_ids($type, $entity);
  if (isset($id)) {
    search_api_track_item_insert($type, array($id));
  }
}

/**
 * Implements hook_entity_update().
 *
 * Marks the item as changed for all indexes on entities of the specified type.
 *
 * @param $entity
 *   The updated entity.
 * @param $type
 *   The entity's type.
 */
function search_api_entity_update($entity, $type) {
  // We only react on entity operations for types with property information, as
  // we don't provide search integration for the others.
  if (!entity_get_property_info($type)) {
    return;
  }
  list($id) = entity_extract_ids($type, $entity);
  if (isset($id)) {
    search_api_track_item_change($type, array($id));
  }
}

/**
 * Implements hook_entity_delete().
 *
 * Removes the item from the tracking table and deletes it from all indexes.
 *
 * @param $entity
 *   The updated entity.
 * @param $type
 *   The entity's type.
 */
function search_api_entity_delete($entity, $type) {
  // We only react on entity operations for types with property information, as
  // we don't provide search integration for the others.
  if (!entity_get_property_info($type)) {
    return;
  }
  list($id) = entity_extract_ids($type, $entity);
  if (isset($id)) {
    search_api_track_item_delete($type, array($id));
  }
}

/**
 * Implements hook_search_api_item_type_info().
 *
 * Adds item types for all entity types with property information.
 */
function search_api_search_api_item_type_info() {
  $types = array();

  foreach (entity_get_property_info() as $type => $property_info) {
    if ($info = entity_get_info($type)) {
      $types[$type] = array(
        'name' => $info['label'],
        'datasource controller' => 'SearchApiEntityDataSourceController',
      );
    }
  }

  return $types;
}

/**
 * Implements hook_modules_enabled().
 */
function search_api_modules_enabled(array $modules) {
  // New modules might offer additional entity types, invalidating the cached
  // item type information.
  drupal_static_reset('search_api_get_item_type_info');
}

/**
 * Implements hook_modules_disabled().
 */
function search_api_modules_disabled(array $modules) {
  // The disabled modules might have offered entity types, which are now
  // invalid. Therefore, clear the cached item type informaiton.
  drupal_static_reset('search_api_get_item_type_info');
}

/**
 * Implements hook_search_api_alter_callback_info().
 */
function search_api_search_api_alter_callback_info() {
  $callbacks['search_api_alter_bundle_filter'] = array(
    'name' => t('Bundle filter'),
    'description' => t('Exclude items from indexing based on their bundle (content type, vocabulary, …).'),
    'class' => 'SearchApiAlterBundleFilter',
    // Filters should be executed first.
    'weight' => -10,
  );
  $callbacks['search_api_alter_add_url'] = array(
    'name' => t('URL field'),
    'description' => t("Adds the item's URL to the indexed data."),
    'class' => 'SearchApiAlterAddUrl',
  );
  $callbacks['search_api_alter_add_aggregation'] = array(
    'name' => t('Aggregated fields'),
    'description' => t('Gives you the ability to define additional fields, containing data from one or more other fields.'),
    'class' => 'SearchApiAlterAddAggregation',
  );
  $callbacks['search_api_alter_add_viewed_entity'] = array(
    'name' => t('Complete entity view'),
    'description' => t('Adds an additional field containing the whole HTML content of the entity when viewed.'),
    'class' => 'SearchApiAlterAddViewedEntity',
  );
  $callbacks['search_api_alter_add_hierarchy'] = array(
    'name' => t('Index hierarchy'),
    'description' => t('Allows to index hierarchical fields along with all their ancestors.'),
    'class' => 'SearchApiAlterAddHierarchy',
  );
  $callbacks['search_api_alter_language_control'] = array(
    'name' => t('Language control'),
    'description' => t('Lets you determine the language of items in the index.'),
    'class' => 'SearchApiAlterLanguageControl',
  );
  $callbacks['search_api_alter_node_access'] = array(
    'name' => t('Node access'),
    'description' => t('Add node access information to the index.'),
    'class' => 'SearchApiAlterNodeAccess',
  );
  $callbacks['search_api_alter_node_status'] = array(
    'name' => t('Exclude unpublished nodes'),
    'description' => t('Exclude unpublished nodes from the index.'),
    'class' => 'SearchApiAlterNodeStatus',
  );

  return $callbacks;
}

/**
 * Implements hook_search_api_processor_info().
 */
function search_api_search_api_processor_info() {
  $processors['search_api_case_ignore'] = array(
    'name' => t('Ignore case'),
    'description' => t('This processor will make searches case-insensitive for all fulltext fields (and, optionally, also for filters on string fields).'),
    'class' => 'SearchApiIgnoreCase',
  );
  $processors['search_api_html_filter'] = array(
    'name' => t('HTML filter'),
    'description' => t('Strips HTML tags from fulltext fields and decodes HTML entities. ' .
        'Use this processor when indexing HTML data, e.g., node bodies for certain text formats.<br />' .
        'The processor also allows to boost (or ignore) the contents of specific elements.'),
    'class' => 'SearchApiHtmlFilter',
    'weight' => 10,
  );
  $processors['search_api_tokenizer'] = array(
    'name' => t('Tokenizer'),
    'description' => t('Tokenizes fulltext data by stripping whitespace. ' .
        'This processor allows you to specify which characters make up words and which characters should be ignored, using regular expression syntax. ' .
        'Otherwise it is up to the search server implementation to decide how to split indexed fulltext data.'),
    'class' => 'SearchApiTokenizer',
    'weight' => 20,
  );
  $processors['search_api_stopwords'] = array(
    'name' => t('Stopwords'),
    'description' => t('This processor prevents certain words from being indexed and removes them from search terms. ' .
        'For best results, it should only be executed after tokenizing.'),
    'class' => 'SearchApiStopWords',
    'weight' => 30,
  );

  return $processors;
}

/**
 * Inserts new unindexed items for all indexes on the specified type.
 *
 * @param $type
 *   The item type of the new items.
 * @param array $item_id
 *   The IDs of the new items.
 */
function search_api_track_item_insert($type, array $item_ids) {
  $conditions = array(
    'enabled' => 1,
    'item_type' => $type,
    'read_only' => 0,
  );
  $indexes = search_api_index_load_multiple(FALSE, $conditions);
  if (!$indexes) {
    return;
  }

  search_api_get_datasource_controller($type)->trackItemInsert($item_ids, $indexes);

  foreach ($indexes as $index) {
    if (!empty($index->options['index_directly'])) {
      $indexed = search_api_index_specific_items_delayed($index, $item_ids);
    }
  }
}

/**
 * Mark the items with the specified IDs as "dirty", i.e., as needing to be reindexed.
 *
 * For indexes for which items should be indexed immediately, the items are
 * indexed directly, instead.
 *
 * @param $type
 *   The type of items, specific to the data source.
 * @param array $item_ids
 *   The IDs of the items to be marked dirty.
 */
function search_api_track_item_change($type, array $item_ids) {
  $conditions = array(
    'enabled' => 1,
    'item_type' => $type,
    'read_only' => 0,
  );
  $indexes = search_api_index_load_multiple(FALSE, $conditions);
  if (!$indexes) {
    return;
  }
  search_api_get_datasource_controller($type)->trackItemChange($item_ids, $indexes);
  foreach ($indexes as $index) {
    if (!empty($index->options['index_directly'])) {
      // For indexes with the index_directly option set, queue the items to be
      // indexed at the end of the request.
      try {
        search_api_index_specific_items_delayed($index, $item_ids);
      }
      catch (SearchApiException $e) {
        watchdog_exception('search_api', $e);
      }
    }
  }
}

/**
 * Marks items as queued for indexing for the specified index.
 *
 * @param SearchApiIndex $index
 *   The index on which items were queued.
 * @param array $item_ids
 *   The ids of the queued items.
 */
function search_api_track_item_queued(SearchApiIndex $index, array $item_ids) {
  $index->datasource()->trackItemQueued($item_ids, $index);
}

/**
 * Marks items as successfully indexed for the specified index.
 *
 * @param SearchApiIndex $index
 *   The index on which items were indexed.
 * @param array $item_ids
 *   The ids of the indexed items.
 */
function search_api_track_item_indexed(SearchApiIndex $index, array $item_ids) {
  $index->datasource()->trackItemIndexed($item_ids, $index);
}

/**
 * Removes items from all indexes.
 *
 * @param $type
 *   The type of the items.
 * @param array $item_ids
 *   The IDs of the deleted items.
 */
function search_api_track_item_delete($type, array $item_ids) {
  // First, delete the item from the tracking table.
  $conditions = array(
    'enabled' => 1,
    'item_type' => $type,
    'read_only' => 0,
  );
  $indexes = search_api_index_load_multiple(FALSE, $conditions);
  if ($indexes) {
    search_api_get_datasource_controller($type)->trackItemDelete($item_ids, $indexes);
  }

  // Then, delete it from all servers. Servers of disabled indexes have to be
  // considered, too!
  unset($conditions['enabled']);
  foreach (search_api_index_load_multiple(FALSE, $conditions) as $index) {
    if ($index->server) {
      $server = $index->server();
      if ($server->enabled) {
        $server->deleteItems($item_ids, $index);
      }
      else {
        $tasks = variable_get('search_api_tasks', array());
        foreach ($item_ids as $id) {
          $tasks[$server->machine_name][$index->machine_name][] = 'delete-' . $id;
        }
        variable_set('search_api_tasks', $tasks);
      }
    }
  }
}

/**
 * Indexes items for the specified index. Only items marked as changed are
 * indexed, in their order of change (if known).
 *
 * @param SearchApiIndex $index
 *   The index on which items should be indexed.
 * @param $limit
 *   The number of items which should be indexed at most. -1 means no limit.
 *
 * @throws SearchApiException
 *   If any error occurs during indexing.
 *
 * @return
 *   Number of successfully indexed items.
 */
function search_api_index_items(SearchApiIndex $index, $limit = -1) {
  // Don't try to index read-only indexes.
  if ($index->read_only) {
    return 0;
  }

  $queue = DrupalQueue::get('search_api_indexing_queue');
  $queue->createQueue();
  $indexed = 0;
  $unlimited = $limit < 0;
  $release_items = array();
  while (($unlimited || $indexed < $limit) && ($item = $queue->claimItem(30))) {
    if ($item->data['index'] === $index->machine_name) {
      $indexed += _search_api_indexing_queue_process($item->data);
      $queue->deleteItem($item);
    }
    else {
      $release_items[] = $item;
    }
  }

  foreach ($release_items as $item) {
    $queue->releaseItem($item);
  }

  if ($unlimited || $indexed < $limit) {
    $ids = search_api_get_items_to_index($index, $unlimited ? -1 : $limit - $indexed);
    if ($ids) {
      $indexed += count(search_api_index_specific_items($index, $ids));
    }
  }

  return $indexed;
}

/**
 * Indexes the specified items on the given index.
 *
 * Items which were successfully indexed are marked as such afterwards.
 *
 * @param SearchApiIndex $index
 *   The index on which items should be indexed.
 * @param array $ids
 *   The IDs of the items which should be indexed.
 *
 * @throws SearchApiException
 *   If any error occurs during indexing.
 *
 * @return
 *   The IDs of all successfully indexed items.
 */
function search_api_index_specific_items(SearchApiIndex $index, array $ids) {
  $items = $index->loadItems($ids);
  // Clone items because data alterations may alter them.
  $cloned_items = array();
  foreach ($items as $id => $item) {
    $cloned_items[$id] = clone $item;
  }
  $indexed = $items ? $index->index($cloned_items) : array();
  if ($indexed) {
    search_api_track_item_indexed($index, $indexed);
    // If some items could not be indexed, we don't want to try re-indexing
    // them right away, so we mark them as "freshly" changed. Sadly, there is
    // no better way than to mark them as indexed first...
    if (count($indexed) < count($ids)) {
      // Believe it or not but this is actually quite faster than the equivalent
      // $diff = array_diff($ids, $indexed);
      $diff = array_keys(array_diff_key(array_flip($ids), array_flip($indexed)));
      $index->datasource()->trackItemIndexed($diff, $index);
      $index->datasource()->trackItemChange($diff, array($index));
    }
  }
  return $indexed;
}

/**
 * Queues items for indexing at the end of the page request.
 *
 * @param SearchApiIndex $index
 *   The index on which items should be indexed.
 * @param array $ids
 *   The IDs of the items which should be indexed.
 *
 * @return array
 *   The current contents of the queue, as a reference.
 *
 * @see search_api_index_specific_items()
 * @see _search_api_index_queued_items()
 */
function &search_api_index_specific_items_delayed(SearchApiIndex $index = NULL, array $ids = array()) {
  // We cannot use drupal_static() here because the static cache is reset during
  // batch processing, which breaks batch handling.
  static $queue = array();
  static $registered = FALSE;

  // Only register the shutdown function once.
  if (empty($registered)) {
    drupal_register_shutdown_function('_search_api_index_queued_items');
    $registered = TRUE;
  }

  // Allow for empty call to just retrieve the queue.
  if ($index && $ids) {
    $index_id = $index->machine_name;
    $queue += array($index_id => array());
    $queue[$index_id] += drupal_map_assoc($ids);
  }

  return $queue;
}

/**
 * Returns a list of items that need to be indexed for the specified index.
 *
 * @param SearchApiIndex $index
 *   The index for which items should be retrieved.
 * @param $limit
 *   The maximum number of items to retrieve. -1 means no limit.
 *
 * @return array
 *   An array of IDs of items that need to be indexed.
 */
function search_api_get_items_to_index(SearchApiIndex $index, $limit = -1) {
  if ($limit == 0) {
    return array();
  }
  return $index->datasource()->getChangedItems($index, $limit);
}

/**
 * Creates a search query on a specified search index.
 *
 * @param $id
 *   The ID or machine name of the index to execute the search on.
 * @param $options
 *   An associative array of options. The following are recognized:
 *   - filters: Either a SearchApiQueryFilterInterface object or an array of
 *     filters used to filter the search.
 *   - sort: An array of sort directives of the form $field => $order, where
 *     $order is either 'ASC' or 'DESC'.
 *   - offset: The position of the first returned search results relative to the
 *     whole result in the index.
 *   - limit: The maximum number of search results to return. -1 means no limit.
 *   - 'query class': The query class to use. Must be a subtype of
 *     SearchApiQueryInterface.
 *   - conjunction: The type of conjunction to use for this query - either
 *     'AND' or 'OR'. 'AND' by default.
 *   - 'parse mode': The mode with which to parse the $keys variable, if it
 *     is set and not already an array. See SearchApiQuery::parseModes() for
 *     parse modes recognized by the SearchApiQuery class.
 *     Subclasses might define additional modes.
 *
 * @return SearchApiQueryInterface
 *   An object for searching on the specified index.
 */
function search_api_query($id, array $options = array()) {
  $index = search_api_index_load($id);
  if (!$index) {
    throw new SearchApiException(t('Unknown index with ID @id.', array('@id' => $id)));
  }
  return $index->query($options);
}

/**
 * Static store for the searches executed on the current page. Can either be
 * used to store an executed search, or to retrieve a previously stored
 * search.
 *
 * @param $search_id
 *   For pages displaying multiple searches, an optional ID identifying the
 *   search in questions. When storing a search, this is filled automatically,
 *   unless it is manually set.
 * @param SearchApiQuery $query
 *   When storing an executed search, the query that was executed. NULL
 *   otherwise.
 * @param array $results
 *   When storing an executed search, the returned results as specified by
 *   SearchApiQueryInterface::execute(). An empty array, otherwise.
 *
 * @return array
 *   If a search with the specified ID was executed, an array containing
 *   ($query, $results) as used in this function's parameters. If $search_id is
 *   NULL, an array of all executed searches will be returned, keyed by ID.
 */
function search_api_current_search($search_id = NULL, SearchApiQuery $query = NULL, array $results = array()) {
  $searches = &drupal_static(__FUNCTION__, array());

  if (isset($query)) {
    if (!isset($search_id)) {
      $search_id = $query->getOption('search id');
    }
    $base = $search_id;
    $i = 0;
    while (isset($searches[$search_id])) {
      $search_id = $base . '-' . ++$i;
    }
    $searches[$search_id] = array($query, $results);
  }

  if (isset($search_id)) {
    return isset($searches[$search_id]) ? $searches[$search_id] : NULL;
  }
  return $searches;
}

/**
 * Returns all field types recognized by the Search API framework.
 *
 * @return array
 *   An associative array with all recognized types as keys, mapped to their
 *   translated display names.
 *
 * @see search_api_default_field_types()
 * @see search_api_get_data_type_info()
 */
function search_api_field_types() {
  $types = search_api_default_field_types();
  foreach (search_api_get_data_type_info() as $id => $type) {
    $types[$id] = $type['name'];
  }
  return $types;
}

/**
 * Returns the default field types recognized by the Search API framework.
 *
 * @return array
 *   An associative array with the default types as keys, mapped to their
 *   translated display names.
 */
function search_api_default_field_types() {
  return array(
    'text' => t('Fulltext'),
    'string' => t('String'),
    'integer' => t('Integer'),
    'decimal' => t('Decimal'),
    'date' => t('Date'),
    'duration' => t('Duration'),
    'boolean' => t('Boolean'),
    'uri' => t('URI'),
  );
}

/**
 * Returns either all custom field type definitions, or a specific one.
 *
 * @param $type
 *   If specified, the type whose definition should be returned.
 *
 * @return array
 *   If $type was not given, an array containing all custom data types, in the
 *   format specified by hook_search_api_data_type_info().
 *   Otherwise, the definition for the given type, or NULL if it is unknown.
 *
 * @see hook_search_api_data_type_info()
 */
function search_api_get_data_type_info($type = NULL) {
  $types = &drupal_static(__FUNCTION__);
  if (!isset($types)) {
    $default_types = search_api_default_field_types();
    $types = module_invoke_all('search_api_data_type_info');
    $types = $types ? $types : array();
    foreach ($types as &$type_info) {
      if (!isset($type_info['fallback']) || !isset($default_types[$type_info['fallback']])) {
        $type_info['fallback'] = 'string';
      }
    }
    drupal_alter('search_api_data_type_info', $types);
  }
  if (isset($type)) {
    return isset($types[$type]) ? $types[$type] : NULL;
  }
  return $types;
}

/**
 * Returns either a list of all available service infos, or a specific one.
 *
 * @see hook_search_api_service_info()
 *
 * @param $id
 *   The ID of the service info to retrieve.
 *
 * @return array
 *   If $id was not specified, an array of all available service classes.
 *   Otherwise, either the service info with the specified id (if it exists),
 *   or NULL.
 */
function search_api_get_service_info($id = NULL) {
  $services = &drupal_static(__FUNCTION__);

  if (!isset($services)) {
    $services = module_invoke_all('search_api_service_info');

    // Allow other modules to alter definitions
    drupal_alter('search_api_service_info', $services);
  }

  if (isset($id)) {
    return isset($services[$id]) ? $services[$id] : NULL;
  }
  return $services;
}

/**
 * Returns information for either all item types, or a specific one.
 *
 * @param $type
 *   If set, the item type whose information should be returned.
 *
 * @return
 *   If $type is given, either an array containing the information of that item
 *   type, or NULL if it is unknown. Otherwise, an array keyed by type IDs
 *   containing the information for all item types. Item type information is
 *   formatted as specified by hook_search_api_item_type_info(), and has all
 *   optional fields filled with the defaults.
 *
 * @see hook_search_api_item_type_info()
 */
function search_api_get_item_type_info($type = NULL) {
  $types = &drupal_static(__FUNCTION__);

  if (!isset($types)) {
    $types = module_invoke_all('search_api_item_type_info');
    drupal_alter('search_api_item_type_info', $types);
  }

  if (isset($type)) {
    return isset($types[$type]) ? $types[$type] : NULL;
  }
  return $types;
}

/**
 * Get a data source controller object for the specified type.
 *
 * @param $type
 *   The type whose data source controller should be returned.
 *
 * @return SearchApiDataSourceControllerInterface
 *   The type's data source controller.
 *
 * @throws SearchApiException
 *   If the type is unknown or specifies an invalid data source controller.
 */
function search_api_get_datasource_controller($type) {
  $datasources = &drupal_static(__FUNCTION__, array());
  if (empty($datasources[$type])) {
    $info = search_api_get_item_type_info($type);
    if (isset($info['datasource controller']) && class_exists($info['datasource controller'])) {
      $datasources[$type] = new $info['datasource controller']($type);
    }
    if (empty($datasources[$type]) || !($datasources[$type] instanceof SearchApiDataSourceControllerInterface)) {
      unset($datasources[$type]);
      throw new SearchApiException(t('Unknown or invalid item type @type.', array('@type' => $type)));
    }
  }
  return $datasources[$type];
}

/**
 * Returns a list of all available data alter callbacks.
 *
 * @see hook_search_api_alter_callback_info()
 *
 * @return array
 *   An array of all available data alter callbacks, keyed by function name.
 */
function search_api_get_alter_callbacks() {
  $callbacks = &drupal_static(__FUNCTION__);

  if (!isset($callbacks)) {
    $callbacks = module_invoke_all('search_api_alter_callback_info');

    // Initialization of optional entries with default values
    foreach ($callbacks as $id => $callback) {
      $callbacks[$id] += array('enabled' => TRUE, 'weight' => 0);
    }
  }

  return $callbacks;
}

/**
 * Returns a list of all available pre- and post-processors.
 *
 * @see hook_search_api_processor_info()
 *
 * @return array
 *   An array of all available processors, keyed by id.
 */
function search_api_get_processors() {
  $processors = &drupal_static(__FUNCTION__);

  if (!isset($processors)) {
    $processors = module_invoke_all('search_api_processor_info');

    // Initialization of optional entries with default values
    foreach ($processors as $id => $processor) {
      $processors[$id] += array('enabled pre' => TRUE, 'enabled post' => TRUE, 'weight' => 0);
    }
  }

  return $processors;
}

/**
 * Implements hook_search_api_query_alter().
 *
 * Adds node access to the query, if enabled.
 *
 * @param SearchApiQueryInterface $query
 *   The SearchApiQueryInterface object representing the search query.
 */
function search_api_search_api_query_alter(SearchApiQueryInterface $query) {
  $index = $query->getIndex();
  // Only add node access if the necessary fields are indexed in the index, and
  // unless disabled explicitly by the query.
  $fields = $index->options['fields'];
  if (!empty($fields['search_api_access_node']) && !empty($fields['status']) && !empty($fields['author']) && !$query->getOption('search_api_bypass_access')) {
    $account = $query->getOption('search_api_access_account', $GLOBALS['user']);
    if (is_numeric($account)) {
      $account = user_load($account);
    }
    if (is_object($account)) {
      try {
        _search_api_query_add_node_access($account, $query);
      }
      catch (SearchApiException $e) {
        watchdog_exception('search_api', $e);
      }
    }
    else {
      watchdog('search_api', 'An illegal user UID was given for node access: @uid.', array('@uid' => $query->getOption('search_api_access_account', $GLOBALS['user'])), WATCHDOG_WARNING);
    }
  }
}

/**
  * Build a node access subquery.
  *
  * @param $account
  *   The user object, who searches.
  *
  * @return SearchApiQueryFilter
  */
function _search_api_query_add_node_access($account, SearchApiQueryInterface $query) {
  if (!user_access('access content', $account)) {
    // Simple hack for returning no results.
    $query->condition('status', 0);
    $query->condition('status', 1);
    watchdog('search_api', 'User @name tried to execute a search, but cannot access content.', array('@name' => theme('username', array('account' => $account))), WATCHDOG_NOTICE);
    return;
  }

  // Only filter for user which don't have full node access.
  if (!user_access('bypass node access', $account)) {
    // Filter by node "published" status.
    if (user_access('view own unpublished content')) {
      $filter = $query->createFilter('OR');
      $filter->condition('status', NODE_PUBLISHED);
      $filter->condition('author', $account->uid);
      $query->filter($filter);
    }
    else {
      $query->condition('status', NODE_PUBLISHED);
    }
    // Filter by node access grants.
    $filter = $query->createFilter('OR');
    $grants = node_access_grants('view', $account);
    foreach ($grants as $realm => $gids) {
      foreach ($gids as $gid) {
        $filter->condition('search_api_access_node', "node_access_$realm:$gid");
      }
    }
    $filter->condition('search_api_access_node', 'node_access__all');
    $query->filter($filter);
  }
}

/**
 * Utility function for determining whether a field of the given type contains
 * text data.
 *
 * @param $type
 *   A string containing the type to check.
 * @param array $allowed
 *   Optionally, an array of allowed types.
 *
 * @return
 *   TRUE if $type is either one of the specified types, or a list of such
 *   values. FALSE otherwise.
 */
function search_api_is_text_type($type, array $allowed = array('text')) {
  return array_search(search_api_extract_inner_type($type), $allowed) !== FALSE;
}

/**
 * Utility function for determining whether a field of the given type contains
 * a list of any kind.
 *
 * @param $type
 *   A string containing the type to check.
 *
 * @return
 *   TRUE iff $type is a list type ("list<*>").
 */
function search_api_is_list_type($type) {
  return substr($type, 0, 5) == 'list<';
}

/**
 * Utility function for determining the nesting level of a list type.
 *
 * @param $type
 *   A string containing the type to check.
 *
 * @return
 *   The nesting level of the type. 0 for singular types, 1 for lists of
 *   singular types, etc.
 */
function search_api_list_nesting_level($type) {
  $level = 0;
  while (search_api_is_list_type($type)) {
    $type = substr($type, 5, -1);
    ++$level;
  }
  return $level;
}

/**
 * Utility function for nesting a type to the same level as another type.
 * I.e., after <code>$t = search_api_nest_type($type, $nested_type);</code> is
 * executed, the following statements will always be true:
 * @code
 * search_api_list_nesting_level($t) == search_api_list_nesting_level($nested_type);
 * search_api_extract_inner_type($t) == search_api_extract_inner_type($type);
 * @endcode
 *
 * @param $type
 *   The type to wrap.
 * @param $nested_type
 *   Another type, determining the nesting level.
 *
 * @return
 *   A list version of $type, as specified above.
 */
function search_api_nest_type($type, $nested_type) {
  while (search_api_is_list_type($nested_type)) {
    $nested_type = substr($nested_type, 5, -1);
    $type = "list<$type>";
  }
  return $type;
}

/**
 * Utility function for extracting the contained primitive type of a list type.
 *
 * @param $type
 *   A string containing the list type to process.
 *
 * @return
 *   A string containing the primitive type contained within the list, e.g.
 *   "text" for "list<text>" (or for "list<list<text>>"). If $type is no list
 *   type, it is returned unchanged.
 */
function search_api_extract_inner_type($type) {
  while (search_api_is_list_type($type)) {
    $type = substr($type, 5, -1);
  }
  return $type;
}

/**
 * Utility function for extracting specific fields from an EntityMetadataWrapper
 * object.
 *
 * @param EntityMetadataWrapper $wrapper
 *   The wrapper from which to extract fields.
 * @param array $fields
 *   The fields to extract, as stored in an index. I.e., the array keys are
 *   field names, the values are arrays with the keys "name", "type", "boost"
 *   and "indexed" (although only "type" is used by this function).
 * @param array $value_options
 *   An array of options that should be passed to the
 *   EntityMetadataWrapper::value() method (see there).
 *
 * @return
 *   The $fields array with additional "value" and "original_type" keys set.
 */
function search_api_extract_fields(EntityMetadataWrapper $wrapper, array $fields, array $value_options = array()) {
  // If $wrapper is a list of entities, we have to aggregate their field values.
  $wrapper_info = $wrapper->info();
  if (search_api_is_list_type($wrapper_info['type'])) {
    foreach ($fields as $field => &$info) {
      $info['value'] = array();
      $info['original_type'] = $info['type'];
    }
    unset($info);
    try {
      foreach ($wrapper as $i => $w) {
        $nested_fields = search_api_extract_fields($w, $fields, $value_options);
        foreach ($nested_fields as $field => $info) {
          if (isset($info['value'])) {
            $fields[$field]['value'][] = $info['value'];
          }
          if (isset($info['original_type'])) {
            $fields[$field]['original_type'] = $info['original_type'];
          }
        }
      }
    }
    catch (EntityMetadataWrapperException $e) {
      // Catch exceptions caused by not set list values.
    }
    return $fields;
  }

  $nested = array();
  $entity_infos = entity_get_info();
  foreach ($fields as $field => &$info) {
    $pos = strpos($field, ':');
    if ($pos === FALSE) {
      // Set "defaults" in case an error occurs later.
      $info['value'] = NULL;
      $info['original_type'] = $info['type'];
      try {
        $info['value'] = $wrapper->$field->value($value_options);
        // For fulltext fields with options, also include the option labels.
        if (search_api_is_text_type($info['type']) && $wrapper->$field->optionsList('view')) {
          _search_api_add_option_values($info['value'], $wrapper->$field->optionsList('view'));
        }
        $property_info = $wrapper->$field->info();
        $info['original_type'] = $property_info['type'];
        // For entities, we extract the entity ID instead of the whole object.
        // @todo Use 'identifier' => TRUE instead of always loading the object.
        $t = search_api_extract_inner_type($property_info['type']);
        if (isset($entity_infos[$t])) {
          // If no object is set, set this field to NULL.
          $info['value'] = $info['value'] ? _search_api_extract_entity_value($wrapper->$field, search_api_is_text_type($info['type'])) : NULL;
        }
      }
      catch (EntityMetadataWrapperException $e) {
        // This might happen for entity-typed properties that are NULL, e.g.,
        // for comments without parent.
      }
    }
    else {
      list($prefix, $key) = explode(':', $field, 2);
      $nested[$prefix][$key] = $info;
    }
  }
  unset($info);

  foreach ($nested as $prefix => $nested_fields) {
    if (isset($wrapper->$prefix)) {
      $nested_fields = search_api_extract_fields($wrapper->$prefix, $nested_fields, $value_options);
      foreach ($nested_fields as $field => $info) {
        $fields["$prefix:$field"] = $info;
      }
    }
    else {
      foreach ($nested_fields as $field => &$info) {
        $info['value'] = NULL;
        $info['original_type'] = $info['type'];
      }
    }
  }
  return $fields;
}

/**
 * Helper method for adding additional text data to fields with an option list.
 */
function _search_api_add_option_values(&$value, array $options) {
  if (is_array($value)) {
    foreach ($value as &$v) {
      _search_api_add_option_values($v, $options);
    }
    return;
  }
  if (is_scalar($value) && isset($options[$value])) {
    $value .= ' ' . $options[$value];
  }
}

/**
 * Helper method for extracting the ID (and possibly label) of an entity-valued field.
 */
function _search_api_extract_entity_value(EntityMetadataWrapper $wrapper, $fulltext = FALSE) {
  $v = $wrapper->value();
  if (is_array($v)) {
    $ret = array();
    foreach ($wrapper as $item) {
      $values = _search_api_extract_entity_value($item, $fulltext);
      if ($values) {
        $ret[] = $values;
      }
    }
    return $ret;
  }
  if ($v) {
    $ret = $wrapper->getIdentifier();
    if ($fulltext && ($label = $wrapper->label())) {
      $ret .= ' ' . $label;
    }
    return $ret;
  }
  return NULL;
}

/**
 * Load the search server with the specified id.
 *
 * @param $id
 *   The search server's id.
 * @param $reset
 *   Whether to reset the internal cache.
 *
 * @return SearchApiServer
 *   An object representing the server with the specified id.
 */
function search_api_server_load($id, $reset = FALSE) {
  $ret = search_api_server_load_multiple(array($id), array(), $reset);
  return $ret ? reset($ret) : FALSE;
}

/**
 * Load multiple servers at once, determined by IDs or machine names, or by
 * other conditions.
 *
 * @see entity_load()
 *
 * @param $ids
 *   An array of server IDs or machine names, or FALSE to load all servers.
 * @param $conditions
 *   An array of conditions on the {search_api_server} table in the form
 *   'field' => $value.
 * @param $reset
 *   Whether to reset the internal entity_load cache.
 *
 * @return array
 *   An array of server objects keyed by machine name.
 */
function search_api_server_load_multiple($ids = array(), $conditions = array(), $reset = FALSE) {
  return entity_load_multiple_by_name('search_api_server', $ids, $conditions, $reset);
}

/**
 * Entity uri callback.
 */
function search_api_server_url(SearchApiServer $server) {
  return array(
    'path' => 'admin/config/search/search_api/server/' . $server->machine_name,
    'options' => array(),
  );
}

/**
 * Title callback for determining which title should be displayed for the
 * "delete" local task.
 *
 * @param Entity $entity
 *   The server or index for which the menu link is displayed.
 *
 * @return string
 *   A translated version of either "Delete" or "Revert".
 */
function search_api_title_delete_page(Entity $entity) {
  return $entity->hasStatus(ENTITY_OVERRIDDEN) ? t('Revert') : t('Delete');
}

/**
 * Access callback for determining if a server's or index' "delete" page should
 * be accessible.
 *
 * @param Entity $entity
 *   The server or index for which the access to the delete page is checked.
 *
 * @return
 *   TRUE if the delete page can be accessed by the user, FALSE otherwise.
 */
function search_api_access_delete_page(Entity $entity) {
  return user_access('administer search_api') && $entity->hasStatus(ENTITY_CUSTOM);
}

/**
 * Inserts a new search server into the database.
 *
 * @param array $values
 *   An array containing the values to be inserted.
 *
 * @return
 *   The newly inserted server's id, or FALSE on error.
 */
function search_api_server_insert(array $values) {
  $server = entity_create('search_api_server', $values);
  $server->is_new = TRUE;
  $server->save();
  return $server->id;
}

/**
 * Changes a server's settings.
 *
 * @param $id
 *   The ID or machine name of the server whose values should be changed.
 * @param array $fields
 *   The new field values to set. The enabled field can't be set this way, use
 *   search_api_server_enable() and search_api_server_disable() instead.
 *
 * @return
 *   1 if fields were changed, 0 if the fields already had the desired values.
 *   FALSE on failure.
 */
function search_api_server_edit($id, array $fields) {
  $server = search_api_server_load($id, TRUE);
  $ret = $server->update($fields);
  return $ret ? 1 : $ret;
}

/**
 * Enables a search server. Will also check for remembered tasks for this server
 * and execute them.
 *
 * @param $id
 *   The ID or machine name of the server to enable.
 *
 * @return
 *   1 on success, 0 or FALSE on failure.
 */
function search_api_server_enable($id) {
  $server = search_api_server_load($id, TRUE);
  $ret = $server->update(array('enabled' => 1));
  return $ret ? 1 : $ret;
}

/**
 * Disables a search server, along with all associated indexes.
 *
 * @param $id
 *   The ID or machine name of the server to disable.
 *
 * @return
 *   1 on success, 0 or FALSE on failure.
 */
function search_api_server_disable($id) {
  $server = search_api_server_load($id, TRUE);
  $ret = $server->update(array('enabled' => 0));
  return $ret ? 1 : $ret;
}

/**
 * Deletes a search server and disables all associated indexes.
 *
 * @param $id
 *   The ID or machine name of the server to delete.
 *
 * @return
 *   1 on success, 0 or FALSE on failure.
 */
function search_api_server_delete($id) {
  $server = search_api_server_load($id, TRUE);
  $server->delete();
  return 1;
}

/**
 * Loads the Search API index with the specified id.
 *
 * @param $id
 *   The index' id.
 * @param $reset
 *   Whether to reset the internal cache.
 *
 * @return SearchApiIndex
 *   A completely loaded index object, or NULL if no such index exists.
 */
function search_api_index_load($id, $reset = FALSE) {
  $ret = search_api_index_load_multiple(array($id), array(), $reset);
  return $ret ? reset($ret) : FALSE;
}

/**
 * Load multiple indexes at once, determined by IDs or machine names, or by
 * other conditions.
 *
 * @see entity_load()
 *
 * @param $ids
 *   An array of index IDs or machine names, or FALSE to load all indexes.
 * @param $conditions
 *   An array of conditions on the {search_api_index} table in the form
 *   'field' => $value.
 * @param $reset
 *   Whether to reset the internal entity_load cache.
 *
 * @return array
 *   An array of index objects keyed by machine name.
 */
function search_api_index_load_multiple($ids = array(), $conditions = array(), $reset = FALSE) {
  // This line is a workaround for a weird PDO bug in PHP 5.2.
  // See http://drupal.org/node/889286.
  new SearchApiIndex();
  return entity_load_multiple_by_name('search_api_index', $ids, $conditions, $reset);
}

/**
 * Determines a search index' indexing status.
 *
 * @param SearchApiIndex $index
 *   The index whose indexing status should be determined.
 *
 * @return array
 *   An associative array containing two keys (in this order):
 *   - indexed: The number of items already indexed in their latest version.
 *   - total: The total number of items that have to be indexed for this index.
 */
function search_api_index_status(SearchApiIndex $index) {
  return $index->datasource()->getIndexStatus($index);
}

/**
 * Entity uri callback.
 */
function search_api_index_url(SearchApiIndex $index) {
  return array(
    'path' => 'admin/config/search/search_api/index/' . $index->machine_name,
    'options' => array(),
  );
}

/**
 * Property callback.
 *
 * @return SearchApiServer
 *   The server this index currently resides on, or NULL if the index
 *   is currently unassigned.
 */
function search_api_index_get_server(SearchApiIndex $index) {
  return $index->server();
}

/**
 * Inserts a new search index into the database.
 *
 * @param array $values
 *   An array containing the values to be inserted.
 *
 * @return
 *   The newly inserted index' id, or FALSE on error.
 */
function search_api_index_insert(array $values) {
  $index = entity_create('search_api_index', $values);
  $index->is_new = TRUE;
  $index->save();
  return $index->id;
}

/**
 * Changes an index' settings.
 *
 * @param $id
 *   The edited index' id.
 * @param array $fields
 *   The new field values to set.
 *
 * @return
 *   1 if fields were changed, 0 if the fields already had the desired values.
 *   FALSE on failure.
 */
function search_api_index_edit($id, array $fields) {
  $index = search_api_index_load($id, TRUE);
  $ret = $index->update($fields);
  return $ret ? 1 : $ret;
}

/**
 * Changes an index' indexed field settings.
 *
 * @param $id
 *   The ID or machine name of the index whose fields should be changed.
 * @param array $fields
 *   The new indexed field settings.
 *
 * @return
 *   1 if the field settings were changed, 0 if they already had the desired
 *   values. FALSE on failure.
 */
function search_api_index_edit_fields($id, array $fields) {
  $index = search_api_index_load($id, TRUE);
  $options = $index->options;
  $options['fields'] = $fields;
  $ret = $index->update(array('options' => $options));
  return $ret ? 1 : $ret;
}

/**
 * Enables a search index.
 *
 * @param $id
 *   The ID or machine name of the index to enable.
 *
 * @throws SearchApiException
 *   If the index' server isn't enabled.
 *
 * @return
 *   1 on success, 0 or FALSE on failure.
 */
function search_api_index_enable($id) {
  $index = search_api_index_load($id, TRUE);
  $ret = $index->update(array('enabled' => 1));
  return $ret ? 1 : $ret;
}

/**
 * Disables a search index.
 *
 * @param $id
 *   The ID or machine name of the index to disable.
 *
 * @return
 *   1 on success, 0 or FALSE on failure.
 */
function search_api_index_disable($id) {
  $index = search_api_index_load($id, TRUE);
  $ret = $index->update(array('enabled' => 0));
  return $ret ? 1 : $ret;
}

/**
 * Schedules a search index for re-indexing.
 *
 * @param $id
 *   The ID or machine name of the index to re-index.
 *
 * @return
 *   TRUE on success, FALSE on failure.
 */
function search_api_index_reindex($id) {
  $index = search_api_index_load($id);
  return $index->reindex();
}

/**
 * Helper method for marking all items on an index as needing re-indexing.
 *
 * @param SearchApiIndex $index
 *   The index whose items should be re-indexed.
 */
function _search_api_index_reindex(SearchApiIndex $index) {
  $index->datasource()->trackItemChange(FALSE, array($index), TRUE);
  _search_api_empty_cron_queue($index);
}

/**
 * Helper method for removing all of an index's jobs from the cron queue.
 *
 * @param SearchApiIndex $index
 *   The index whose jobs should be removed.
 * @param $mark_changed
 *   If TRUE, mark all items in the queue as "changed" again. Defaults to FALSE.
 */
function _search_api_empty_cron_queue(SearchApiIndex $index, $mark_changed = FALSE) {
  $index_id = $index->machine_name;
  $queue = DrupalQueue::get('search_api_indexing_queue');
  $queue->createQueue();
  $ids = array();
  $release_items = array();
  while ($item = $queue->claimItem()) {
    if ($item->data['index'] === $index_id) {
      $queue->deleteItem($item);
      if ($mark_changed) {
        $ids = array_merge($ids, $item->data['items']);
      }
    }
    else {
      $release_items[] = $item;
    }
  }

  foreach ($release_items as $item) {
    $queue->releaseItem($item);
  }

  if ($ids) {
    $index->datasource()->trackItemChange($ids, array($index), TRUE);
  }
}

/**
 * Clears a search index and schedules all of its items for re-indexing.
 *
 * @param $id
 *   The ID or machine name of the index to clear.
 *
 * @return
 *   TRUE on success, FALSE on failure.
 */
function search_api_index_clear($id) {
  $index = search_api_index_load($id);
  return $index->clear();
}

/**
 * Deletes a search index.
 *
 * @param $id
 *   The ID or machine name of the index to delete.
 *
 * @return
 *   TRUE on success, FALSE on failure.
 */
function search_api_index_delete($id) {
  $index = search_api_index_load($id);
  if (!$index) {
    return FALSE;
  }
  $index->delete();
  return TRUE;
}

/**
 * Options list callback for search indexes.
 *
 * @return array
 *   An array of search index machine names mapped to their human-readable
 *   names.
 */
function search_api_index_options_list() {
  $ret = array(
    NULL => '- ' . t('All') . ' -',
  );
  foreach (search_api_index_load_multiple(FALSE) as $id => $index) {
    $ret[$id] = $index->name;
  }
  return $ret;
}

/**
 * Cron queue worker callback for indexing some items.
 *
 * @param array $task
 *   An associative array containing:
 *   - index: The ID of the index on which items should be indexed.
 *   - items: The items that should be indexed.
 *
 * @return
 *   The number of successfully indexed items.
 */
function _search_api_indexing_queue_process(array $task) {
  $index = search_api_index_load($task['index']);
  try {
    if ($index && $index->enabled && !$index->read_only && $task['items']) {
      $indexed = search_api_index_specific_items($index, $task['items']);
      $num = count($indexed);
      // If some items couldn't be indexed, mark them as dirty again.
      if ($num < count($task['items'])) {
        // Believe it or not but this is actually quite faster than the equivalent
        // $diff = array_diff($task['items'], $indexed);
        $diff = array_keys(array_diff_key(array_flip($task['items']), array_flip($indexed)));
        // Mark the items as dirty again.
        $index->datasource()->trackItemChange($diff, array($index), TRUE);
      }
      if ($num) {
        watchdog('search_api', t('Indexed @num items for index @name', array('@num' => $num, '@name' => $index->name)), NULL, WATCHDOG_INFO);
      }
      return $num;
    }
  }
  catch (SearchApiException $e) {
    watchdog_exception('search_api', $e);
  }
}

/**
 * Shutdown function which indexes all queued items, if any.
 */
function _search_api_index_queued_items() {
  $queue = &search_api_index_specific_items_delayed();

  try {
    if ($queue) {
      $indexes = search_api_index_load_multiple(array_keys($queue));
      foreach ($indexes as $index_id => $index) {
        search_api_index_specific_items($index, $queue[$index_id]);
      }
    }

    // Reset the queue so we don't index the items twice by accident.
    $queue = array();
  }
  catch (SearchApiException $e) {
    watchdog_exception('search_api', $e);
  }
}

/**
 * Helper function to be used as a "property info alter" callback.
 *
 * If a wrapped entity is passed to this function, all its available properties
 * and fields, regardless of bundle, are added to the wrapper.
 */
function _search_api_wrapper_add_all_properties(EntityMetadataWrapper $wrapper, array $property_info) {
  if ($properties = entity_get_all_property_info($wrapper->type())) {
    $property_info['properties'] = $properties;
  }
  return $property_info;
}

/**
 * Helper function for converting data to a custom type.
 */
function _search_api_convert_custom_type($callback, $value, $original_type, $type, $nesting_level) {
  if ($nesting_level == 0) {
    return call_user_func($callback, $value, $original_type, $type);
  }
  if (!is_array($value)) {
    return NULL;
  }
  --$nesting_level;
  $values = array();
  foreach ($value as $v) {
    $v = _search_api_convert_custom_type($callback, $v, $original_type, $type, $nesting_level);
    if (isset($v) && !(is_array($v) && !$v)) {
      $values[] = $v;
    }
  }
  return $values;
}

/**
 * Create and set a batch for indexing items.
 *
 * @param SearchApiIndex $index
 *   The index for which items should be indexed.
 * @param $batch_size
 *   Number of items to index per batch.
 * @param $limit
 *   Maximum number of items to index.
 * @param $remaining
 *   Remaining items to index.
 * @param $drush
 *   Boolean specifying whether this was called from drush or not.
 */
function _search_api_batch_indexing_create(SearchApiIndex $index, $batch_size, $limit, $remaining, $drush = FALSE) {
  if ($limit !== 0 && $batch_size !== 0) {
    $t = !empty($drush) ? 'dt' : 't';

    if ($limit < 0 || $limit > $remaining) {
      $limit = $remaining;
    }
    if ($batch_size < 0) {
      $batch_size = $remaining;
    }
    $batch = array(
      'title' => $t('Indexing items'),
      'operations' => array(
        array('_search_api_batch_indexing_callback', array($index, $batch_size, $limit, $drush)),
      ),
      'progress_message' => $t('Completed about @percentage% of the indexing operation.'),
      'finished' => '_search_api_batch_indexing_finished',
      'file' => drupal_get_path('module', 'search_api') . '/search_api.module',
    );
    batch_set($batch);
    return TRUE;
  }
  return FALSE;
}

/**
 * Batch API callback for the indexing functionality.
 *
 * @param SearchApiIndex $index
 *   The index for which items should be indexed.
 * @param integer $batch_size
 *   Number of items to index per batch.
 * @param integer $limit
 *   Maximum number of items to index.
 * @param boolean $drush
 *   Boolean specifying whether this was called from drush or not.
 * @param array $context
 *   The batch context.
 */
function _search_api_batch_indexing_callback(SearchApiIndex $index, $batch_size, $limit, $drush = FALSE, array &$context) {
  // Persistent data among batch runs.
  if (!isset($context['sandbox']['limit'])) {
    $context['sandbox']['limit'] = $limit;
    $context['sandbox']['batch_size'] = $batch_size;
    $context['sandbox']['progress'] = 0;
  }

  // Persistent data for results.
  if (!isset($context['results']['indexed'])) {
    $context['results']['indexed'] = 0;
    $context['results']['not indexed'] = 0;
    $context['results']['drush'] = $drush;
  }

  // Number of items to index for this run.
  $to_index = min($context['sandbox']['limit'] - $context['sandbox']['progress'], $context['sandbox']['batch_size']);

  // Index the items.
  $indexed = search_api_index_items($index, $to_index);
  $context['results']['indexed'] += $indexed;

  // Display progress message.
  if ($indexed > 0) {
    $format_plural = $context['results']['drush'] === TRUE ? '_search_api_drush_format_plural' : 'format_plural';
    $context['message'] = $format_plural($context['results']['indexed'], 'Successfully indexed 1 item.', 'Successfully indexed @count items.');
  }

  // Some items couldn't be indexed.
  if ($indexed !== $to_index) {
    $context['results']['not indexed'] += $to_index - $indexed;
  }

  $context['sandbox']['progress'] += $to_index;

  // Everything has been indexed.
  if ($indexed === 0 || $context['sandbox']['progress'] >= $context['sandbox']['limit']) {
    $context['finished'] = 1;
  }
  else {
    $context['finished'] = $context['sandbox']['progress'] / $context['sandbox']['limit'];
  }
}

/**
 * Batch API finishing callback for the indexing functionality.
 *
 * @param boolean $success
 *   Result of the batch operation.
 * @param array $results
 *   Results.
 * @param array $operations
 *   Remaining batch operation to process.
 */
function _search_api_batch_indexing_finished($success, $results, $operations) {
  // Check if called from drush.
  if (!empty($results['drush'])) {
    $drupal_set_message = 'drush_log';
    $format_plural = '_search_api_drush_format_plural';
    $t = 'dt';
    $success_message = 'success';
  }
  else {
    $drupal_set_message = 'drupal_set_message';
    $format_plural = 'format_plural';
    $t = 't';
    $success_message = 'status';
  }

  // Display result messages.
  if ($success) {
    if (!empty($results['indexed'])) {
      $drupal_set_message($format_plural($results['indexed'], 'Successfully indexed 1 item.', 'Successfully indexed @count items.'), $success_message);

      if (!empty($results['not indexed'])) {
       $drupal_set_message($format_plural($results['not indexed'], '1 item could not be indexed. Check the logs for details.', '@count items could not be indexed. Check the logs for details.'), 'warning');
      }
    }
    else {
      $drupal_set_message($t("Couldn't index items. Check the logs for details."), 'error');
    }
  }
  else {
    $drupal_set_message($t("An error occurred while trying to index items. Check the logs for details."), 'error');
  }

}