class RubyLsp::Listeners::Completion

# File lib/ruby_lsp/listeners/completion.rb, line 20
def initialize(response_builder, global_state, nesting, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
  @response_builder = response_builder
  @global_state = global_state
  @index = T.let(global_state.index, RubyIndexer::Index)
  @nesting = nesting
  @typechecker_enabled = typechecker_enabled
  @uri = uri

  dispatcher.register(
    self,
    :on_constant_path_node_enter,
    :on_constant_read_node_enter,
    :on_call_node_enter,
  )
end

# File lib/ruby_lsp/listeners/completion.rb, line 106
def on_call_node_enter(node)
  name = node.message
  return unless name

  case name
  when "require"
    complete_require(node)
  when "require_relative"
    complete_require_relative(node)
  else
    complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
  end
end

# File lib/ruby_lsp/listeners/completion.rb, line 59
def on_constant_path_node_enter(node)
  return if @global_state.typechecker

  name = constant_name(node)
  return if name.nil?

  top_level_reference = if name.start_with?("::")
    name = name.delete_prefix("::")
    true
  else
    false
  end

  # If we're trying to provide completion for an aliased namespace, we need to first discover it's real name in
  # order to find which possible constants match the desired search
  *namespace, incomplete_name = name.split("::")
  aliased_namespace = T.must(namespace).join("::")
  namespace_entries = @index.resolve(aliased_namespace, @nesting)
  return unless namespace_entries

  real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)

  candidates = @index.prefix_search(
    "#{real_namespace}::#{incomplete_name}",
    top_level_reference ? [] : @nesting,
  )
  candidates.each do |entries|
    # The only time we may have a private constant reference from outside of the namespace is if we're dealing
    # with ConstantPath and the entry name doesn't start with the current nesting
    first_entry = T.must(entries.first)
    next if first_entry.visibility == :private && !first_entry.name.start_with?("#{@nesting}::")

    constant_name = T.must(first_entry.name.split("::").last)

    full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"

    @response_builder << build_entry_completion(
      full_name,
      name,
      node,
      entries,
      top_level_reference || top_level?(T.must(entries.first).name),
    )
  end
end

# File lib/ruby_lsp/listeners/completion.rb, line 38
def on_constant_read_node_enter(node)
  return if @global_state.typechecker

  name = constant_name(node)
  return if name.nil?

  candidates = @index.prefix_search(name, @nesting)
  candidates.each do |entries|
    complete_name = T.must(entries.first).name
    @response_builder << build_entry_completion(
      complete_name,
      name,
      node,
      entries,
      top_level?(complete_name),
    )
  end
end