class RuboCop::Cop::Performance::HashEachMethods

def autocorrect(node)
  receiver, _second_method = *node
  _caller, first_method = *receiver
  lambda do |corrector|
    case first_method
    when :keys, :values
      return correct_implicit(node, corrector) if receiver.receiver.nil?
      correct_key_value_each(node, corrector)
    else
      return correct_implicit(node, corrector) if receiver.nil?
      correct_plain_each(node, corrector)
    end
  end
end

def check_argument(variable)
  return unless variable.block_argument?
  (@args ||= {})[variable.name] = variable.used?
end

def correct_args(node, corrector)
  args = node.parent.children[1]
  used_arg = "|#{@args.detect { |_k, v| v }.first}|"
  corrector.replace(args.source_range, used_arg)
end

def correct_implicit(node, corrector)
  method = @args.include?(:k) ? :key : :value
  new_source = "each_#{method}"
  corrector.replace(node.loc.expression, new_source)
  correct_args(node, corrector)
end

def correct_key_value_each(node, corrector)
  receiver = node.receiver
  new_source = receiver.receiver.source +
               ".each_#{receiver.method_name[0..-2]}"
  corrector.replace(node.loc.expression, new_source)
end

def correct_plain_each(node, corrector)
  method = @args.include?(:k) ? :key : :value
  new_source = node.receiver.source + ".each_#{method}"
  corrector.replace(node.loc.expression, new_source)
  correct_args(node, corrector)
end

def kv_range(outer_node)
  inner_node = outer_node.children.first
  inner_node.loc.selector.join(outer_node.loc.selector)
end

def on_block(node)
  register_each_offense(node)
  register_kv_offense(node)
end

def plain_range(outer_node)
  outer_node.loc.selector
end

def register_each_offense(node)
  plain_each(node) do |target, k, v|
    return if @args[k] && @args[v]
    used = @args[k] ? :key : :value
    add_offense(
      target, plain_range(target), format(message,
                                          "each_#{used}",
                                          :each)
    )
  end
end

def register_kv_offense(node)
  kv_each(node) do |target, method|
    add_offense(
      target, kv_range(target), format(message,
                                       "each_#{method[0..-2]}",
                                       "#{method}.each")
    )
  end
end