module RuboCop::Cop::RSpec::InflectedHelper

def autocorrect_inflected(node)
  predicate_in_actual?(node) do |predicate, to, matcher|
    lambda do |corrector|
      remove_predicate(corrector, predicate)
      corrector.replace(node.loc.selector,
                        true?(to, matcher) ? 'to' : 'not_to')
      rewrite_matcher(corrector, predicate, matcher)
    end
  end
end

def boolean_matcher?(node)
  if cop_config['Strict']
    be_boolthy?(node)
  else
    be_bool?(node) || be_boolthy?(node)
  end
end

def check_inflected(node)
  predicate_in_actual?(node) do |predicate|
    add_offense(
      node,
      location: :expression,
      message: message_inflected(predicate)
    )
  end
end

def message_inflected(predicate)
  _recv, predicate_name, = *predicate
  format(MSG_INFLECTED,
         predicate_name: predicate_name,
         matcher_name: to_predicate_matcher(predicate_name))
end

def predicate?(sym)
  sym.to_s.end_with?('?')
end

def remove_predicate(corrector, predicate)
  range = range_between(
    predicate.loc.dot.begin_pos,
    predicate.loc.expression.end_pos
  )
  corrector.remove(range)
  block_range = block_loc(predicate)
  corrector.remove(block_range) if block_range
end

def rewrite_matcher(corrector, predicate, matcher)
  args = args_loc(predicate).source
  block_loc = block_loc(predicate)
  block = block_loc ? block_loc.source : ''
  _recv, name, = *predicate
  corrector.replace(matcher.loc.expression,
                    to_predicate_matcher(name) + args + block)
end

def to_predicate_matcher(name)
  case name = name.to_s
  when 'is_a?'
    'be_a'
  when 'instance_of?'
    'be_an_instance_of'
  when 'include?', 'respond_to?'
    name[0..-2]
  when /^has_/
    name.sub('has_', 'have_')[0..-2]
  else
    "be_#{name[0..-2]}"
  end
end

def true?(to, matcher)
  _recv, name, arg = *matcher
  result = case name
           when :be, :eq
             arg.true_type?
           when :be_truthy, :a_truthy_value
             true
           when :be_falsey, :be_falsy, :a_falsey_value, :a_falsy_value
             false
           end
  to == :to ? result : !result
end