/**
  * merge top level multi-queries and resolve returned pageIds into Title objects.
  *
  * WARNING: experimental API
  *
  * @param string $query the user query
  * @param \Elastica\Response $response Response from elasticsearch _suggest api
  * @param array $profiles the suggestion profiles
  * @param int $limit Maximum suggestions to return, -1 for unlimited
  * @return SearchSuggestionSet a set of Suggestions
  */
 protected function postProcessSuggest(\Elastica\Response $response, $profiles, $limit = -1)
 {
     $this->logContext['elasticTookMs'] = intval($response->getQueryTime() * 1000);
     $data = $response->getData();
     unset($data['_shards']);
     $suggestions = array();
     foreach ($data as $name => $results) {
         $discount = $profiles[$name]['discount'];
         foreach ($results as $suggested) {
             foreach ($suggested['options'] as $suggest) {
                 $output = SuggestBuilder::decodeOutput($suggest['text']);
                 if ($output === null) {
                     // Ignore broken output
                     continue;
                 }
                 $pageId = $output['id'];
                 $type = $output['type'];
                 $score = $discount * $suggest['score'];
                 if (!isset($suggestions[$pageId]) || $score > $suggestions[$pageId]->getScore()) {
                     $suggestion = new SearchSuggestion($score, null, null, $pageId);
                     // If it's a title suggestion we have the text
                     if ($type === SuggestBuilder::TITLE_SUGGESTION) {
                         $suggestion->setText($output['text']);
                     }
                     $suggestions[$pageId] = $suggestion;
                 }
             }
         }
     }
     // simply sort by existing scores
     uasort($suggestions, function ($a, $b) {
         return $b->getScore() - $a->getScore();
     });
     $this->logContext['hitsTotal'] = count($suggestions);
     if ($limit > 0) {
         $suggestions = array_slice($suggestions, 0, $limit, true);
     }
     $this->logContext['hitsReturned'] = count($suggestions);
     $this->logContext['hitsOffset'] = 0;
     // we must fetch redirect data for redirect suggestions
     $missingText = array();
     foreach ($suggestions as $id => $suggestion) {
         if ($suggestion->getText() === null) {
             $missingText[] = $id;
         }
     }
     if (!empty($missingText)) {
         // Experimental.
         //
         // Second pass query to fetch redirects.
         // It's not clear if it's the best option, this will slowdown the whole query
         // when we hit a redirect suggestion.
         // Other option would be to encode redirects as a payload resulting in a
         // very big index...
         // XXX: we support only the content index
         $type = $this->connection->getPageType($this->indexBaseName, Connection::CONTENT_INDEX_TYPE);
         // NOTE: we are already in a poolCounterWork
         // Multi get is not supported by elastica
         $redirResponse = null;
         try {
             $redirResponse = $type->request('_mget', 'GET', array('ids' => $missingText), array('_source_include' => 'redirect'));
             if ($redirResponse->isOk()) {
                 $this->logContext['elasticTook2PassMs'] = intval($redirResponse->getQueryTime() * 1000);
                 $docs = $redirResponse->getData();
                 foreach ($docs['docs'] as $doc) {
                     if (empty($doc['_source']['redirect'])) {
                         continue;
                     }
                     // We use the original query, we should maybe use the variant that generated this result?
                     $text = Util::chooseBestRedirect($this->term, $doc['_source']['redirect']);
                     if (!empty($suggestions[$doc['_id']])) {
                         $suggestions[$doc['_id']]->setText($text);
                     }
                 }
             } else {
                 LoggerFactory::getInstance('CirrusSearch')->warning('Unable to fetch redirects for suggestion {query} with results {ids} : {error}', array('query' => $this->term, 'ids' => serialize($missingText), 'error' => $redirResponse->getError()));
             }
         } catch (\Elastica\Exception\ExceptionInterface $e) {
             LoggerFactory::getInstance('CirrusSearch')->warning('Unable to fetch redirects for suggestion {query} with results {ids} : {error}', array('query' => $this->term, 'ids' => serialize($missingText), 'error' => $this->extractMessage($e)));
         }
     }
     return new SearchSuggestionSet(array_filter($suggestions, function ($suggestion) {
         // text should be not empty for suggestions
         return $suggestion->getText() != null;
     }));
 }
 /**
  * This implementation will run the completion suggester if it's enabled and if the
  * query is for NS_MAIN. Fallback to SearchEngine default implemention otherwise.
  *
  * @param string $search the user query
  * @return SearchSuggestionSet the suggestions
  */
 public function searchSuggestions($search)
 {
     $config = ConfigFactory::getDefaultInstance()->makeConfig('CirrusSearch');
     $useCompletionSuggester = $config->getElement('CirrusSearchUseCompletionSuggester');
     $context = RequestContext::getMain();
     $request = $context->getRequest();
     // Allow experimentation with query parameters
     if ($request && $request->getVal('cirrusUseCompletionSuggester') === 'yes') {
         $useCompletionSuggester = true;
     }
     if (!$useCompletionSuggester) {
         // Completion suggester is not enabled, fallback to
         // default implementation
         return $this->searchSuggestionsPrefixSearchFallback($search);
     }
     // We use Title to extract namespace from a Title string
     // We append a random letter behind just in case the search
     // string ends with ':'.
     $title = Title::newFromText($search . "A");
     if ($title->getNamespace() != NS_MAIN || count($this->namespaces) != 1 || reset($this->namespaces) != NS_MAIN) {
         // Fallback to prefix search if we are not on content namespace
         return $this->searchSuggestionsPrefixSearchFallback($search);
     }
     $user = $context->getUser();
     // offset is omitted, searchSuggestion does not support
     // scrolling results
     $suggester = new CompletionSuggester($this->connection, $this->limit, $config, $this->namespaces, $user, $this->indexBaseName);
     // Not really useful, mostly for testing purpose
     $variants = $request->getArray('cirrusCompletionSuggesterVariant');
     if (empty($variants)) {
         global $wgContLang;
         $variants = $wgContLang->autoConvertToAllVariants($search);
     } else {
         if (count($variants) > 3) {
             // We should not allow too many variants
             $variants = array_slice($variants, 0, 3);
         }
     }
     $response = $suggester->suggest($search, $variants);
     if ($response->isOK()) {
         // Errors will be logged, let's try the exact db match
         $suggestions = $response->getValue();
     } else {
         $suggestions = SearchSuggestionSet::emptySuggestionSet();
     }
     // preload the titles with LinkBatch
     $titles = $suggestions->map(function ($sugg) {
         return $sugg->getSuggestedTitle();
     });
     $lb = new LinkBatch($titles);
     $lb->setCaller(__METHOD__);
     $lb->execute();
     $results = $suggestions->map(function ($sugg) {
         return $sugg->getSuggestedTitle()->getPrefixedText();
     });
     // now we can trim
     $search = trim($search);
     // Rescore results with an exact title match
     $rescorer = new SearchExactMatchRescorer();
     $rescoredResults = $rescorer->rescore($search, $this->namespaces, $results, $this->limit);
     if (count($rescoredResults) > 0) {
         $found = array_search($rescoredResults[0], $results);
         if ($found === false) {
             // If the first result is not in the previous array it
             // means that we found a new exact match
             $exactMatch = SearchSuggestion::fromTitle(0, Title::newFromText($rescoredResults[0]));
             $suggestions->prepend($exactMatch);
             $suggestions->shrink($this->limit);
         } else {
             // if the first result is not the same we need to rescore
             if ($found > 0) {
                 $suggestions->rescore($found);
             }
         }
     }
     return $suggestions;
 }