class Pry::Command::FindMethod

def additional_info(header, method)
  if opts.content?
    ': ' + colorize_code(matched_method_lines(header, method))
  else
    ""
  end
end

def content_search(namespace)
  search_all_methods(namespace) do |meth|
    begin
      meth.source =~ pattern
    rescue RescuableException
      false
    end
  end
end

def matched_method_lines(header, method)
  method.source.split(/\n/).select { |x| x =~ pattern }.join(
    "\n#{' ' * header.length}"
  )
end

def name_search(namespace)
  search_all_methods(namespace) do |meth|
    meth.name =~ pattern
  end
end

def options(opt)
  opt.on :n, :name,    "Search for a method by name"
  opt.on :c, :content, "Search for a method based on content in Regex form"
end

def pattern
  @pattern ||= ::Regexp.new args[0]
end

def print_matches(matches)
  grouped = matches.group_by(&:owner)
  order = grouped.keys.sort_by { |x| x.name || x.to_s }
  order.each do |klass|
    print_matches_for_class(klass, grouped)
  end
end

def print_matches_for_class(klass, grouped)
  output.puts bold(klass.name)
  grouped[klass].each do |method|
    header = method.name_with_owner
    output.puts header + additional_info(header, method)
  end
end

def process
  return if args.empty?
  klass = search_class
  matches = opts.content? ? content_search(klass) : name_search(klass)
  show_search_results(matches)
end

def recurse_namespace(klass, done = {}, &block)
  return if !klass.is_a?(Module) || done[klass]
  done[klass] = true
  yield klass
  klass.constants.each do |name|
    next if klass.autoload?(name)
    begin
      const = klass.const_get(name)
    rescue RescuableException # rubocop:disable Lint/HandleExceptions
      # constant loading is an inexact science at the best of times,
      # this often happens when a constant was .autoload? but someone
      # tried to load it. It's now not .autoload? but will still raise
      # a NameError when you access it.
    else
      recurse_namespace(const, done, &block)
    end
  end
end

def search_all_methods(namespace)
  done = Hash.new { |h, k| h[k] = {} }
  matches = []
  recurse_namespace(namespace) do |klass|
    methods = Pry::Method.all_from_class(klass) + Pry::Method.all_from_obj(klass)
    methods.each do |method|
      next if done[method.owner][method.name]
      done[method.owner][method.name] = true
      matches << method if yield method
    end
  end
  matches
end

def search_class
  klass = if args[1]
            target.eval(args[1])
          else
            target_self
          end
  klass.is_a?(Module) ? klass : klass.class
end

def show_search_results(matches)
  if matches.empty?
    output.puts bold("No Methods Matched")
  else
    print_matches(matches)
  end
end