module RuboCop::Cop::RSpec::InflectedHelper

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, to, matcher|
    msg = message_inflected(predicate)
    add_offense(node, message: msg) 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 message_inflected(predicate)
  format(MSG_INFLECTED,
         predicate_name: predicate.method_name,
         matcher_name: to_predicate_matcher(predicate.method_name))
end

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

def remove_predicate(corrector, predicate)
  range = predicate.loc.dot.with(
    end_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 : ''
  corrector.replace(
    matcher.loc.expression,
    to_predicate_matcher(predicate.method_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 'exist?', 'exists?'
    'exist'
  when /^has_/
    name.sub('has_', 'have_')[0..-2]
  else
    "be_#{name[0..-2]}"
  end
end

def true?(to_symbol, matcher)
  result = case matcher.method_name
           when :be, :eq
             matcher.first_argument.true_type?
           when :be_truthy, :a_truthy_value
             true
           when :be_falsey, :be_falsy, :a_falsey_value, :a_falsy_value
             false
           end
  to_symbol == :to ? result : !result
end