module Sidekiq::Rescue::Dsl::ClassMethods

def assign_sidekiq_rescue_options(errors:, delay:, limit:, jitter:)
  self.sidekiq_rescue_options ||= {}
  self.sidekiq_rescue_options = self.sidekiq_rescue_options.merge(errors => { delay: delay, limit: limit,
                                                                              jitter: jitter })
end

def sidekiq_rescue(*errors, delay: Sidekiq::Rescue.config.delay, limit: Sidekiq::Rescue.config.limit,
                   jitter: Sidekiq::Rescue.config.jitter)
  unpacked_errors = validate_and_unpack_error_argument(errors)
  validate_delay_argument(delay)
  validate_limit_argument(limit)
  validate_jitter_argument(jitter)
  assign_sidekiq_rescue_options(errors: unpacked_errors, delay: delay, limit: limit, jitter: jitter)
end

def sidekiq_rescue_error_group_with_options_by(exception)
  sidekiq_rescue_options.reverse_each.find do |error_group, _options|
    Array(error_group).any? { |error_klass| exception.is_a?(error_klass) }
  end
end

def validate_and_unpack_error_argument(error)
  error_arg_valid = error.any? && error.flatten.all? { |e| e < StandardError } if error.is_a?(Array)
  return error.flatten if error_arg_valid
  raise ArgumentError,
        "error must be an ancestor of StandardError"
end

def validate_delay_argument(delay)
  return if delay.is_a?(Integer) || delay.is_a?(Float)
  if delay.is_a?(Proc)
    raise ArgumentError, "delay proc must accept counter as argument" if delay.arity.zero?
    return
  end
  raise ArgumentError,
        "delay must be integer, float or proc"
end

def validate_jitter_argument(jitter)
  return if jitter.is_a?(Integer) || jitter.is_a?(Float)
  raise ArgumentError,
        "jitter must be integer or float"
end

def validate_limit_argument(limit)
  raise ArgumentError, "limit must be integer" if limit && !limit.is_a?(Integer)
end