// Copyright 2017-2018 ccls Authors
// SPDX-License-Identifier: Apache-2.0

#include "include_complete.hh"

#include "filesystem.hh"
#include "match.hh"
#include "platform.hh"
#include "project.hh"

#include <llvm/ADT/Twine.h>
#include <llvm/Support/Threading.h>
#include <llvm/Support/Timer.h>

#include <unordered_set>
using namespace llvm;

#include <thread>

namespace ccls {
namespace {

struct CompletionCandidate {
  std::string absolute_path;
  lsCompletionItem completion_item;
};

std::string ElideLongPath(const std::string &path) {
  if (g_config->completion.include.maxPathSize <= 0 ||
      (int)path.size() <= g_config->completion.include.maxPathSize)
    return path;

  size_t start = path.size() - g_config->completion.include.maxPathSize;
  return ".." + path.substr(start + 2);
}

size_t TrimCommonPathPrefix(const std::string &result,
                            const std::string &trimmer) {
#ifdef _WIN32
  std::string s = result, t = trimmer;
  std::transform(s.begin(), s.end(), s.begin(), ::tolower);
  std::transform(t.begin(), t.end(), t.begin(), ::tolower);
  if (s.compare(0, t.size(), t) == 0)
    return t.size();
#else
  if (result.compare(0, trimmer.size(), trimmer) == 0)
    return trimmer.size();
#endif
  return 0;
}

// Returns true iff angle brackets should be used.
bool TrimPath(Project *project, std::string &path) {
  size_t pos = 0;
  bool angle = false;
  for (auto &[root, folder] : project->root2folder) {
    size_t pos1 = 0;
    for (auto &search : folder.angle_search_list)
      pos1 = std::max(pos1, TrimCommonPathPrefix(path, search));
    if (pos1 > pos) {
      pos = pos1;
      angle = true;
    }

    pos1 = TrimCommonPathPrefix(path, root);
    for (auto &search : folder.quote_search_list)
      pos1 = std::max(pos1, TrimCommonPathPrefix(path, search));
    if (pos1 > pos) {
      pos = pos1;
      angle = false;
    }
  }
  path = path.substr(pos);
  return angle;
}

lsCompletionItem BuildCompletionItem(const std::string &path,
                                     bool use_angle_brackets) {
  lsCompletionItem item;
  item.label = ElideLongPath(path);
  item.detail = path; // the include path, used in de-duplicating
  item.textEdit.newText = path;
  item.insertTextFormat = lsInsertTextFormat::PlainText;
  item.use_angle_brackets_ = use_angle_brackets;
  item.kind = lsCompletionItemKind::File;
  item.priority_ = 0;
  return item;
}
} // namespace

IncludeComplete::IncludeComplete(Project *project)
    : is_scanning(false), project_(project) {}

void IncludeComplete::Rescan() {
  if (is_scanning)
    return;

  completion_items.clear();
  absolute_path_to_completion_item.clear();
  inserted_paths.clear();

  if (!match_ && (g_config->completion.include.whitelist.size() ||
                  g_config->completion.include.blacklist.size()))
    match_ =
        std::make_unique<GroupMatch>(g_config->completion.include.whitelist,
                                     g_config->completion.include.blacklist);

  is_scanning = true;
  std::thread([this]() {
    set_thread_name("include");
    std::unordered_set<std::string> angle_set, quote_set;
    for (auto &[root, folder] : project_->root2folder) {
      for (const std::string &search : folder.angle_search_list)
        if (angle_set.insert(search).second)
          InsertIncludesFromDirectory(search, true);
      for (const std::string &search : folder.quote_search_list)
        if (quote_set.insert(search).second)
          InsertIncludesFromDirectory(search, false);
    }

    is_scanning = false;
  })
      .detach();
}

void IncludeComplete::InsertCompletionItem(const std::string &absolute_path,
                                           lsCompletionItem &&item) {
  if (inserted_paths.insert({item.detail, inserted_paths.size()}).second) {
    completion_items.push_back(item);
    // insert if not found or with shorter include path
    auto it = absolute_path_to_completion_item.find(absolute_path);
    if (it == absolute_path_to_completion_item.end() ||
        completion_items[it->second].detail.length() > item.detail.length()) {
      absolute_path_to_completion_item[absolute_path] =
          completion_items.size() - 1;
    }
  } else {
    lsCompletionItem &inserted_item =
        completion_items[inserted_paths[item.detail]];
    // Update |use_angle_brackets_|, prefer quotes.
    if (!item.use_angle_brackets_)
      inserted_item.use_angle_brackets_ = false;
  }
}

void IncludeComplete::AddFile(const std::string &path) {
  if (!EndsWithAny(path, g_config->completion.include.suffixWhitelist))
    return;
  if (match_ && !match_->IsMatch(path))
    return;

  std::string trimmed_path = path;
  bool use_angle_brackets = TrimPath(project_, trimmed_path);
  lsCompletionItem item = BuildCompletionItem(trimmed_path, use_angle_brackets);

  std::unique_lock<std::mutex> lock(completion_items_mutex, std::defer_lock);
  if (is_scanning)
    lock.lock();
  InsertCompletionItem(path, std::move(item));
}

void IncludeComplete::InsertIncludesFromDirectory(std::string directory,
                                                  bool use_angle_brackets) {
  directory = NormalizePath(directory);
  EnsureEndsInSlash(directory);
  if (match_ && !match_->IsMatch(directory))
    return;
  bool include_cpp = directory.find("include/c++") != std::string::npos;

  std::vector<CompletionCandidate> results;
  GetFilesInFolder(
      directory, true /*recursive*/, false /*add_folder_to_path*/,
      [&](const std::string &path) {
        if (!include_cpp &&
            !EndsWithAny(path, g_config->completion.include.suffixWhitelist))
          return;
        if (match_ && !match_->IsMatch(directory + path))
          return;

        CompletionCandidate candidate;
        candidate.absolute_path = directory + path;
        candidate.completion_item =
            BuildCompletionItem(path, use_angle_brackets);
        results.push_back(candidate);
      });

  std::lock_guard<std::mutex> lock(completion_items_mutex);
  for (CompletionCandidate &result : results)
    InsertCompletionItem(result.absolute_path,
                         std::move(result.completion_item));
}

std::optional<lsCompletionItem>
IncludeComplete::FindCompletionItemForAbsolutePath(
    const std::string &absolute_path) {
  std::lock_guard<std::mutex> lock(completion_items_mutex);

  auto it = absolute_path_to_completion_item.find(absolute_path);
  if (it == absolute_path_to_completion_item.end())
    return std::nullopt;
  return completion_items[it->second];
}
} // namespace ccls