class RuboCop::OptionsValidator

def boolean_or_empty_cache?
  !@options.key?(:cache) || %w[true false].include?(@options[:cache])
end

def disable_parallel_when_invalid_option_combo
  return unless @options.key?(:parallel)
  invalid_flags = invalid_arguments_for_parallel
  return if invalid_flags.empty?
  @options.delete(:parallel)
  puts '-P/--parallel is being ignored because ' \
       "it is not compatible with #{invalid_flags.join(', ')}."
end

def display_only_fail_level_offenses_with_autocorrect?
  @options.key?(:display_only_fail_level_offenses) && @options.key?(:autocorrect)
end

def except_syntax?
  @options.key?(:except) && (@options[:except] & %w[Lint/Syntax Syntax]).any?
end

def format_message_from(name, cop_names)
  message = 'Unrecognized cop or department: %<name>s.'
  message_with_candidate = "%<message>s\nDid you mean? %<candidate>s"
  corrections = NameSimilarity.find_similar_names(name, cop_names)
  if corrections.empty?
    format(message, name: name)
  else
    format(message_with_candidate, message: format(message, name: name),
                                   candidate: corrections.join(', '))
  end
end

def incompatible_options
  @incompatible_options ||= @options.keys & Options::EXITING_OPTIONS
end

def initialize(options)
  @options = options
end

def invalid_arguments_for_parallel
  [('--auto-gen-config' if @options.key?(:auto_gen_config)),
   ('-F/--fail-fast'    if @options.key?(:fail_fast)),
   ('--profile'         if @options[:profile]),
   ('--memory'          if @options[:memory]),
   ('--cache false'     if @options > { cache: 'false' })].compact
end

def only_includes_redundant_disable?
  @options.key?(:only) &&
    (@options[:only] & %w[Lint/RedundantCopDisableDirective RedundantCopDisableDirective]).any?
end

def validate_auto_gen_config
  return if @options.key?(:auto_gen_config)
  message = '--%<flag>s can only be used together with --auto-gen-config.'
  %i[exclude_limit offense_counts auto_gen_timestamp
     auto_gen_only_exclude].each do |option|
    if @options.key?(option)
      raise OptionArgumentError, format(message, flag: option.to_s.tr('_', '-'))
    end
  end
end

def validate_autocorrect
  if @options.key?(:safe_autocorrect) && @options.key?(:autocorrect_all)
    message = Rainbow(<<~MESSAGE).red
      Error: Both safe and unsafe autocorrect options are specified, use only one.
    MESSAGE
    raise OptionArgumentError, message
  end
  return if @options.key?(:autocorrect)
  return unless @options.key?(:disable_uncorrectable)
  raise OptionArgumentError,
        format('--disable-uncorrectable can only be used together with --autocorrect.')
end

def validate_cache_enabled_for_cache_root
  return unless @options[:cache] == 'false'
  raise OptionArgumentError, '--cache-root cannot be used with --cache false'
end

def validate_compatibility # rubocop:disable Metrics/MethodLength
  if only_includes_redundant_disable?
    raise OptionArgumentError, 'Lint/RedundantCopDisableDirective cannot be used with --only.'
  end
  raise OptionArgumentError, 'Syntax checking cannot be turned off.' if except_syntax?
  unless boolean_or_empty_cache?
    raise OptionArgumentError, '-C/--cache argument must be true or false'
  end
  if display_only_fail_level_offenses_with_autocorrect?
    raise OptionArgumentError, '--autocorrect cannot be used with ' \
                               '--display-only-fail-level-offenses.'
  end
  validate_auto_gen_config
  validate_autocorrect
  validate_display_only_failed
  validate_display_only_failed_and_display_only_correctable
  validate_display_only_correctable_and_autocorrect
  disable_parallel_when_invalid_option_combo
  return if incompatible_options.size <= 1
  raise OptionArgumentError, "Incompatible cli options: #{incompatible_options.inspect}"
end

def validate_cop_list(names)
  return unless names
  cop_names = Cop::Registry.global.names
  departments = Cop::Registry.global.departments.map(&:to_s)
  names.each do |name|
    next if cop_names.include?(name)
    next if departments.include?(name)
    next if SYNTAX_DEPARTMENTS.include?(name)
    raise IncorrectCopNameError, format_message_from(name, cop_names)
  end
end

def validate_cop_options
  %i[only except].each { |opt| OptionsValidator.validate_cop_list(@options[opt]) }
end

def validate_display_only_correctable_and_autocorrect
  return unless @options.key?(:autocorrect)
  return if !@options.key?(:display_only_correctable) &&
            !@options.key?(:display_only_safe_correctable)
  raise OptionArgumentError,
        '--autocorrect cannot be used with --display-only-[safe-]correctable.'
end

def validate_display_only_failed
  return unless @options.key?(:display_only_failed)
  return if @options[:format] == 'junit'
  raise OptionArgumentError,
        format('--display-only-failed can only be used together with --format junit.')
end

def validate_display_only_failed_and_display_only_correctable
  return unless @options.key?(:display_only_failed)
  return if !@options.key?(:display_only_correctable) &&
            !@options.key?(:display_only_safe_correctable)
  raise OptionArgumentError,
        format('--display-only-failed cannot be used together with other display options.')
end

def validate_exclude_limit_option
  return if /^\d+$/.match?(@options[:exclude_limit])
  # Emulate OptionParser's behavior to make failures consistent regardless
  # of option order.
  raise OptionParser::MissingArgument
end