module SidekiqUniqueJobs

def config
  @config ||= reset! # rubocop:disable ThreadSafety/ClassInstanceVariable
end

def configure(options = {})
  if block_given?
    yield config
  else
    options.each do |key, val|
      config.send(:"#{key}=", val)
    end
  end
end

def constantize(str)
  return str.class             if str.is_a?(Sidekiq::Job) # sidekiq v6.x
  return str                   unless str.is_a?(String)
  return Object.const_get(str) unless str.include?("::")
  names = str.split("::")
  names.shift if names.empty? || names.first.empty?
  names.inject(Object) do |constant, name|
    # the false flag limits search for name to under the constant namespace
    #   which mimics Rails' behaviour
    constant.const_get(name, false)
  end
end

def disable!(&block)
  toggle(false, &block)
end

def disabled?
  !enabled?
end

def enable!(&block)
  toggle(true, &block)
end

def enabled?
  config.enabled
end

def fetch_redis_version
  Sidekiq.default_configuration.redis_info["redis_version"]
end

def locks
  config.locks
end

def logger
  config.logger
end

def logger=(other)
  config.logger = other
end

def logging?
  config.logger_enabled
end

def now
  Time.now
end

def now_f
  now.to_f
end

def reflect
  yield reflections if block_given?
end

def reflections
  @reflections ||= Reflections.new # rubocop:disable ThreadSafety/ClassInstanceVariable
end

def reset!
  @config = SidekiqUniqueJobs::Config.default # rubocop:disable ThreadSafety/ClassInstanceVariable
end

def safe_constantize(str)
  constantize(str)
rescue NameError => ex
  case ex.message
  when /uninitialized constant/
    str
  else
    raise
  end
end

def strategies
  config.strategies
end

def toggle(enabled)
  if block_given?
    enabled_was = config.enabled
    config.enabled = enabled
    yield
    config.enabled = enabled_was
  else
    config.enabled = enabled
  end
end

def use_config(tmp_config = {})
  raise ::ArgumentError, "#{name}.#{__method__} needs a block" unless block_given?
  old_config = config.to_h
  reset!
  configure(tmp_config)
  yield
ensure
  reset!
  configure(old_config.to_h)
end

def validate_worker(options)
  raise NotUniqueWorker, options unless (lock_type = options[LOCK])
  lock_class = locks[lock_type]
  lock_class.validate_options(options)
end

def validate_worker!(options)
  lock_config = validate_worker(options)
  raise InvalidWorker, lock_config unless lock_config.errors.empty?
end

def version
  VERSION
end