class RubyIndexer::Index

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 14
def initialize
  # Holds all entries in the index using the following format:
  # {
  #  "Foo" => [#<Entry::Class>, #<Entry::Class>],
  #  "Foo::Bar" => [#<Entry::Class>],
  # }
  @entries = T.let({}, T::Hash[String, T::Array[Entry]])

  # Holds all entries in the index using a prefix tree for searching based on prefixes to provide autocompletion
  @entries_tree = T.let(PrefixTree[T::Array[Entry]].new, PrefixTree[T::Array[Entry]])

  # Holds references to where entries where discovered so that we can easily delete them
  # {
  #  "/my/project/foo.rb" => [#<Entry::Class>, #<Entry::Class>],
  #  "/my/project/bar.rb" => [#<Entry::Class>],
  # }
  @files_to_entries = T.let({}, T::Hash[String, T::Array[Entry]])

  # Holds all require paths for every indexed item so that we can provide autocomplete for requires
  @require_paths_tree = T.let(PrefixTree[IndexablePath].new, PrefixTree[IndexablePath])
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 65
def <<(entry)
  name = entry.name

  (@entries[name] ||= []) << entry
  (@files_to_entries[entry.file_path] ||= []) << entry
  @entries_tree.insert(name, T.must(@entries[name]))
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 74
def [](fully_qualified_name)
  @entries[fully_qualified_name.delete_prefix("::")]
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 37
def delete(indexable)
  # For each constant discovered in `path`, delete the associated entry from the index. If there are no entries
  # left, delete the constant from the index.
  @files_to_entries[indexable.full_path]&.each do |entry|
    name = entry.name
    entries = @entries[name]
    next unless entries

    # Delete the specific entry from the list for this name
    entries.delete(entry)

    # If all entries were deleted, then remove the name from the hash and from the prefix tree. Otherwise, update
    # the prefix tree with the current entries
    if entries.empty?
      @entries.delete(name)
      @entries_tree.delete(name)
    else
      @entries_tree.insert(name, entries)
    end
  end

  @files_to_entries.delete(indexable.full_path)

  require_path = indexable.require_path
  @require_paths_tree.delete(require_path) if require_path
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 210
def follow_aliased_namespace(name)
  return name if @entries[name]

  parts = name.split("::")
  real_parts = []

  (parts.length - 1).downto(0).each do |i|
    current_name = T.must(parts[0..i]).join("::")
    entry = @entries[current_name]&.first

    case entry
    when Entry::Alias
      target = entry.target
      return follow_aliased_namespace("#{target}::#{real_parts.join("::")}")
    when Entry::UnresolvedAlias
      resolved = resolve_alias(entry)

      if resolved.is_a?(Entry::UnresolvedAlias)
        raise UnresolvableAliasError, "The constant #{resolved.name} is an alias to a non existing constant"
      end

      target = resolved.target
      return follow_aliased_namespace("#{target}::#{real_parts.join("::")}")
    else
      real_parts.unshift(T.must(parts[i]))
    end
  end

  real_parts.join("::")
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 116
def fuzzy_search(query)
  return @entries.flat_map { |_name, entries| entries } unless query

  normalized_query = query.gsub("::", "").downcase

  results = @entries.filter_map do |name, entries|
    similarity = DidYouMean::JaroWinkler.distance(name.gsub("::", "").downcase, normalized_query)
    [entries, -similarity] if similarity > ENTRY_SIMILARITY_THRESHOLD
  end
  results.sort_by!(&:last)
  results.flat_map(&:first)
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 171
def index_all(indexable_paths: RubyIndexer.configuration.indexables, &block)
  # Calculate how many paths are worth 1% of progress
  progress_step = (indexable_paths.length / 100.0).ceil

  indexable_paths.each_with_index do |path, index|
    if block && index % progress_step == 0
      progress = (index / progress_step) + 1
      break unless block.call(progress)
    end

    index_single(path)
  end
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 186
def index_single(indexable_path, source = nil)
  content = source || File.read(indexable_path.full_path)
  result = Prism.parse(content)
  collector = Collector.new(self, result, indexable_path.full_path)
  collector.collect(result.value)

  require_path = indexable_path.require_path
  @require_paths_tree.insert(require_path, indexable_path) if require_path
rescue Errno::EISDIR, Errno::ENOENT
  # If `path` is a directory, just ignore it and continue indexing. If the file doesn't exist, then we also ignore
  # it
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 97
def prefix_search(query, nesting = nil)
  unless nesting
    results = @entries_tree.search(query)
    results.uniq!
    return results
  end

  results = nesting.length.downto(0).flat_map do |i|
    prefix = T.must(nesting[0...i]).join("::")
    namespaced_query = prefix.empty? ? query : "#{prefix}::#{query}"
    @entries_tree.search(namespaced_query)
  end

  results.uniq!
  results
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 135
def resolve(name, nesting)
  if name.start_with?("::")
    name = name.delete_prefix("::")
    results = @entries[name] || @entries[follow_aliased_namespace(name)]
    return results&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e }
  end

  nesting.length.downto(0).each do |i|
    namespace = T.must(nesting[0...i]).join("::")
    full_name = namespace.empty? ? name : "#{namespace}::#{name}"

    # If we find an entry with `full_name` directly, then we can already return it, even if it contains aliases -
    # because the user might be trying to jump to the alias definition.
    #
    # However, if we don't find it, then we need to search for possible aliases in the namespace. For example, in
    # the LSP itself we alias `RubyLsp::Interface` to `LanguageServer::Protocol::Interface`, which means doing
    # `RubyLsp::Interface::Location` is allowed. For these cases, we need some way to realize that the
    # `RubyLsp::Interface` part is an alias, that has to be resolved
    entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
    return entries.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e } if entries
  end

  nil
rescue UnresolvableAliasError
  nil
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 244
def resolve_method(method_name, receiver_name)
  method_entries = self[method_name]
  owner_entries = self[receiver_name]
  return unless owner_entries && method_entries

  owner_name = T.must(owner_entries.first).name
  T.cast(
    method_entries.grep(Entry::Member).select do |entry|
      T.cast(entry, Entry::Member).owner&.name == owner_name
    end,
    T::Array[Entry::Member],
  )
end

# File lib/ruby_indexer/lib/ruby_indexer/index.rb, line 79
def search_require_paths(query)
  @require_paths_tree.search(query)
end