class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically

def attribute_defining_method?(method_name)
  RuboCop::RSpec::FactoryBot.attribute_defining_methods
    .include?(method_name)
end

def autocorrect(corrector, node)
  if node.parenthesized?
    autocorrect_replacing_parens(corrector, node)
  else
    autocorrect_without_parens(corrector, node)
  end
end

def autocorrect_replacing_parens(corrector, node)
  left_braces, right_braces = braces(node)
  corrector.replace(node.location.begin, " #{left_braces}")
  corrector.replace(node.location.end, right_braces)
end

def autocorrect_without_parens(corrector, node)
  left_braces, right_braces = braces(node)
  argument = node.first_argument
  expression = argument.location.expression
  corrector.insert_before(expression, left_braces)
  corrector.insert_after(expression, right_braces)
end

def braces(node)
  if value_hash_without_braces?(node.first_argument)
    ['{ { ', ' } }']
  else
    ['{ ', ' }']
  end
end

def offensive_receiver?(receiver, node)
  receiver.nil? ||
    receiver.self_type? ||
    receiver_matches_first_block_argument?(receiver, node)
end

def on_block(node)
  attributes = factory_attributes(node) || []
  attributes = [attributes] unless attributes.is_a?(Array) # rubocop:disable Style/ArrayCoercion, Lint/RedundantCopDisableDirective
  attributes.each do |attribute|
    next unless offensive_receiver?(attribute.receiver, node)
    next if proc?(attribute) || association?(attribute.first_argument)
    add_offense(attribute) do |corrector|
      autocorrect(corrector, attribute)
    end
  end
end

def proc?(attribute)
  value_matcher(attribute).to_a.all?(&:block_pass_type?)
end

def receiver_matches_first_block_argument?(receiver, node)
  first_block_argument = node.arguments.first
  !first_block_argument.nil? &&
    receiver.lvar_type? &&
    receiver.node_parts == first_block_argument.node_parts
end

def reserved_method?(method_name)
  RuboCop::RSpec::FactoryBot.reserved_methods.include?(method_name)
end

def value_hash_without_braces?(node)
  node.hash_type? && !node.braces?
end