class RuboCop::Cop::Style::FirstParameterIndentation

def base_range(send_node, arg_node)
  Parser::Source::Range.new(processed_source.buffer,
                            send_node.source_range.begin_pos,
                            arg_node.source_range.begin_pos)
end

def column_of(range)
  source = range.source.strip
  if source.include?("\n")
    previous_code_line(range.line + source.count("\n") + 1) =~ /\S/
  else
    display_column(range)
  end
end

def message(arg_node)
  return 'Bad indentation of the first parameter.' if arg_node.nil?
  send_node = arg_node.parent
  text = base_range(send_node, arg_node).source.strip
  base = if text !~ /\n/ && special_inner_call_indentation?(send_node)
           "`#{text}`"
         elsif text.lines.reverse_each.first =~ /^\s*#/
           'the start of the previous line (not counting the comment)'
         else
           'the start of the previous line'
         end
  format('Indent the first parameter one step more than %s.', base)
end

def on_send(node)
  _receiver, method_name, *args = *node
  return if args.empty?
  return if operator?(method_name)
  base_indentation = if special_inner_call_indentation?(node)
                       column_of(base_range(node, args.first))
                     else
                       previous_code_line(args.first.loc.line) =~ /\S/
                     end
  check_alignment([args.first],
                  base_indentation + configured_indentation_width)
end

def previous_code_line(line_number)
  @comment_lines ||=
    processed_source
    .comments
    .select { |c| begins_its_line?(c.loc.expression) }
    .map { |c| c.loc.line }
  line = ''
  while line.blank? || @comment_lines.include?(line_number)
    line_number -= 1
    line = processed_source.lines[line_number - 1]
  end
  line
end

def special_inner_call_indentation?(node)
  return false if style == :consistent
  parent = node.parent
  return false unless parent
  return false unless parent.send_type?
  _receiver, method_name, *_args = *parent
  # :[]= is a send node, but we want to treat it as an assignment.
  return false if method_name == :[]=
  return false if !parentheses?(parent) &&
                  style == :special_for_inner_method_call_in_parentheses
  # The node must begin inside the parent, otherwise node is the first
  # part of a chained method call.
  node.source_range.begin_pos > parent.source_range.begin_pos
end