// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ui/webui/ash/settings/search/search_handler.h"

#include <algorithm>

#include "base/strings/string_number_conversions.h"
#include "chrome/browser/ui/webui/ash/settings/pages/os_settings_sections.h"
#include "chrome/browser/ui/webui/ash/settings/search/hierarchy.h"
#include "chrome/browser/ui/webui/ash/settings/search/mojom/search_result_icon.mojom.h"
#include "chrome/browser/ui/webui/ash/settings/search/search_concept.h"
#include "chrome/grit/generated_resources.h"
#include "chromeos/ash/components/local_search_service/public/cpp/local_search_service_proxy.h"
#include "ui/base/l10n/l10n_util.h"

namespace ash::settings {

namespace mojom {
using ::chromeos::settings::mojom::Section;
using ::chromeos::settings::mojom::Setting;
using ::chromeos::settings::mojom::Subpage;
}  // namespace mojom

namespace {

bool ContainsSectionResult(const std::vector<mojom::SearchResultPtr>& results,
                           mojom::Section section) {
  return std::ranges::any_of(results, [section](const auto& result) {
    return result->type == mojom::SearchResultType::kSection &&
           section == result->id->get_section();
  });
}

bool ContainsSubpageResult(const std::vector<mojom::SearchResultPtr>& results,
                           mojom::Subpage subpage) {
  return std::ranges::any_of(results, [subpage](const auto& result) {
    return result->type == mojom::SearchResultType::kSubpage &&
           subpage == result->id->get_subpage();
  });
}

}  // namespace

SearchHandler::SearchHandler(
    SearchTagRegistry* search_tag_registry,
    OsSettingsSections* sections,
    Hierarchy* hierarchy,
    local_search_service::LocalSearchServiceProxy* local_search_service_proxy)
    : search_tag_registry_(search_tag_registry),
      sections_(sections),
      hierarchy_(hierarchy) {
  local_search_service_proxy->GetIndex(
      local_search_service::IndexId::kCrosSettings,
      local_search_service::Backend::kLinearMap,
      index_remote_.BindNewPipeAndPassReceiver());
  DCHECK(index_remote_.is_bound());

  search_tag_registry_->AddObserver(this);
}

SearchHandler::~SearchHandler() {
  search_tag_registry_->RemoveObserver(this);
}

void SearchHandler::BindInterface(
    mojo::PendingReceiver<mojom::SearchHandler> pending_receiver) {
  receivers_.Add(this, std::move(pending_receiver));
}

void SearchHandler::Search(const std::u16string& query,
                           uint32_t max_num_results,
                           mojom::ParentResultBehavior parent_result_behavior,
                           SearchCallback callback) {
  // Search for 5x the maximum set of results. If there are many matches for
  // a query, it may be the case that |index_| returns some matches with higher
  // SearchResultDefaultRank values later in the list. Requesting up to 5x the
  // maximum number ensures that such results will be returned and can be ranked
  // accordingly when sorted.
  uint32_t max_local_search_service_results = 5 * max_num_results;

  index_remote_->Find(
      query, max_local_search_service_results,
      base::BindOnce(&SearchHandler::OnFindComplete,
                     weak_ptr_factory_.GetWeakPtr(), std::move(callback),
                     max_num_results, parent_result_behavior));
}

void SearchHandler::Observe(
    mojo::PendingRemote<mojom::SearchResultsObserver> observer) {
  observers_.Add(std::move(observer));
}

void SearchHandler::OnRegistryUpdated() {
  for (auto& observer : observers_) {
    observer->OnSearchResultsChanged();
  }
}

std::vector<mojom::SearchResultPtr> SearchHandler::GenerateSearchResultsArray(
    const std::vector<local_search_service::Result>&
        local_search_service_results,
    uint32_t max_num_results,
    mojom::ParentResultBehavior parent_result_behavior) const {
  std::vector<mojom::SearchResultPtr> search_results;
  for (const auto& result : local_search_service_results) {
    mojom::SearchResultPtr result_ptr = ResultToSearchResult(result);
    if (result_ptr) {
      search_results.push_back(std::move(result_ptr));
    }
  }

  std::sort(search_results.begin(), search_results.end(), CompareSearchResults);

  // Now that the results have been sorted, limit the size of to
  // |max_num_results|.
  search_results.resize(
      std::min(static_cast<size_t>(max_num_results), search_results.size()));

  if (parent_result_behavior ==
      mojom::ParentResultBehavior::kAllowParentResults) {
    AddParentResults(max_num_results, &search_results);
  }

  return search_results;
}

void SearchHandler::OnFindComplete(
    SearchCallback callback,
    uint32_t max_num_results,
    mojom::ParentResultBehavior parent_result_behavior,
    local_search_service::ResponseStatus response_status,
    const std::optional<std::vector<local_search_service::Result>>&
        local_search_service_results) {
  if (response_status != local_search_service::ResponseStatus::kSuccess) {
    LOG(ERROR) << "Cannot search; LocalSearchService returned "
               << static_cast<int>(response_status)
               << ". Returning empty results array.";
    std::move(callback).Run({});
    return;
  }

  std::move(callback).Run(
      GenerateSearchResultsArray(local_search_service_results.value(),
                                 max_num_results, parent_result_behavior));
}

void SearchHandler::AddParentResults(
    uint32_t max_num_results,
    std::vector<mojom::SearchResultPtr>* search_results) const {
  auto it = search_results->begin();
  while (search_results->size() < max_num_results &&
         it != search_results->end()) {
    const mojom::SearchResultPtr& result = *it;
    switch (result->type) {
      case mojom::SearchResultType::kSection:
        // Sections have no parents; nothing to do.
        break;

      case mojom::SearchResultType::kSubpage: {
        const Hierarchy::SubpageMetadata& metadata =
            hierarchy_->GetSubpageMetadata(result->id->get_subpage());

        // Nested subpage.
        if (metadata.parent_subpage) {
          it = AddSubpageResultIfPossible(it, result, *metadata.parent_subpage,
                                          result->relevance_score,
                                          search_results);
          break;
        }

        // Top-level subpage.
        it = AddSectionResultIfPossible(it, result, metadata.section,
                                        search_results);
        break;
      }

      case mojom::SearchResultType::kSetting: {
        const Hierarchy::SettingMetadata& metadata =
            hierarchy_->GetSettingMetadata(result->id->get_setting());

        // Nested setting.
        if (metadata.primary.subpage) {
          it = AddSubpageResultIfPossible(it, result, *metadata.primary.subpage,
                                          result->relevance_score,
                                          search_results);
          break;
        }

        // Top-level setting.
        it = AddSectionResultIfPossible(it, result, metadata.primary.section,
                                        search_results);
        break;
      }
    }

    ++it;
  }
}

std::vector<mojom::SearchResultPtr>::iterator
SearchHandler::AddSectionResultIfPossible(
    const std::vector<mojom::SearchResultPtr>::iterator& curr_position,
    const mojom::SearchResultPtr& child_result,
    mojom::Section section,
    std::vector<mojom::SearchResultPtr>* results) const {
  // If |results| already includes |section|, do not add it again.
  if (ContainsSectionResult(*results, section)) {
    return curr_position;
  }

  mojom::SearchResultPtr section_result =
      hierarchy_->GetSectionMetadata(section).ToSearchResult(
          child_result->relevance_score);

  // Don't add a result for a parent section if it has the exact same text as
  // the child result, since this results in a broken-looking UI.
  if (section_result->text == child_result->text) {
    return curr_position;
  }

  return results->insert(curr_position + 1, std::move(section_result));
}

std::vector<mojom::SearchResultPtr>::iterator
SearchHandler::AddSubpageResultIfPossible(
    const std::vector<mojom::SearchResultPtr>::iterator& curr_position,
    const mojom::SearchResultPtr& child_result,
    mojom::Subpage subpage,
    double relevance_score,
    std::vector<mojom::SearchResultPtr>* results) const {
  // If |results| already includes |subpage|, do not add it again.
  if (ContainsSubpageResult(*results, subpage)) {
    return curr_position;
  }

  mojom::SearchResultPtr subpage_result =
      hierarchy_->GetSubpageMetadata(subpage).ToSearchResult(
          child_result->relevance_score);

  // Don't add a result for a parent subpage if it has the exact same text as
  // the child result, since this results in a broken-looking UI.
  if (subpage_result->text == child_result->text) {
    return curr_position;
  }

  return results->insert(
      curr_position + 1,
      hierarchy_->GetSubpageMetadata(subpage).ToSearchResult(relevance_score));
}

mojom::SearchResultPtr SearchHandler::ResultToSearchResult(
    const local_search_service::Result& result) const {
  const SearchConcept* search_concept =
      search_tag_registry_->GetTagMetadata(result.id);

  // If the concept was not registered, no metadata is available. This can occur
  // if the search tag was dynamically unregistered during the asynchronous
  // Find() call.
  if (!search_concept) {
    return nullptr;
  }

  // |result| is expected to have one position, whose ID is a stringified int.
  DCHECK_EQ(1u, result.positions.size());
  int content_id;
  if (!base::StringToInt(result.positions[0].content_id, &content_id)) {
    return nullptr;
  }

  std::string url;
  mojom::SearchResultIdentifierPtr result_id;
  std::vector<std::u16string> hierarchy_strings;
  switch (search_concept->type) {
    case mojom::SearchResultType::kSection: {
      mojom::Section section = search_concept->id.section;
      url = GetModifiedUrl(*search_concept, section);
      result_id = mojom::SearchResultIdentifier::NewSection(section);
      hierarchy_strings.push_back(
          l10n_util::GetStringUTF16(IDS_INTERNAL_APP_SETTINGS));
      break;
    }
    case mojom::SearchResultType::kSubpage: {
      mojom::Subpage subpage = search_concept->id.subpage;
      url = GetModifiedUrl(*search_concept,
                           hierarchy_->GetSubpageMetadata(subpage).section);
      result_id = mojom::SearchResultIdentifier::NewSubpage(subpage);
      hierarchy_strings = hierarchy_->GenerateAncestorHierarchyStrings(subpage);
      break;
    }
    case mojom::SearchResultType::kSetting: {
      mojom::Setting setting = search_concept->id.setting;
      url = GetModifiedUrl(
          *search_concept,
          hierarchy_->GetSettingMetadata(setting).primary.section);
      result_id = mojom::SearchResultIdentifier::NewSetting(setting);
      hierarchy_strings = hierarchy_->GenerateAncestorHierarchyStrings(setting);
      break;
    }
  }

  return mojom::SearchResult::New(
      /*text=*/l10n_util::GetStringUTF16(content_id),
      /*canonical_text=*/
      l10n_util::GetStringUTF16(search_concept->canonical_message_id), url,
      search_concept->icon, result.score, hierarchy_strings,
      search_concept->default_rank,
      /*was_generated_from_text_match=*/true, search_concept->type,
      std::move(result_id));
}

std::string SearchHandler::GetModifiedUrl(const SearchConcept& search_concept,
                                          mojom::Section section) const {
  return sections_->GetSection(section)->ModifySearchResultUrl(
      search_concept.type, search_concept.id,
      search_concept.url_path_with_parameters);
}

// static
bool SearchHandler::CompareSearchResults(const mojom::SearchResultPtr& first,
                                         const mojom::SearchResultPtr& second) {
  // Compute the difference between the results' default rankings. Note that
  // kHigh is declared before kMedium which is declared before kLow, so a
  // negative value indicates that |first| is ranked higher than |second| and a
  // positive value indicates that |second| is ranked higher than |first|.
  int32_t default_rank_diff = static_cast<int32_t>(first->default_rank) -
                              static_cast<int32_t>(second->default_rank);
  if (default_rank_diff < 0) {
    return true;
  }
  if (default_rank_diff > 0) {
    return false;
  }

  // At this point, the default ranks are equal, so compare relevance scores. A
  // higher relevance score indicates a better text match, so the reverse is
  // true this time.
  if (first->relevance_score > second->relevance_score) {
    return true;
  }
  if (first->relevance_score < second->relevance_score) {
    return false;
  }

  // Default rank and relevance scores are equal, so prefer the result which is
  // higher on the hierarchy. kSection is declared before kSubpage which is
  // declared before kSetting, so follow the same pattern from default ranks
  // above. Note that if the types are equal, this will return false, which
  // induces a strict weak ordering.
  return static_cast<int32_t>(first->type) < static_cast<int32_t>(second->type);
}

}  // namespace ash::settings