module SidekiqUniqueJobs::Orphans::Manager

def current_timestamp
  Time.now.to_i
end

def default_task
  SidekiqUniqueJobs::TimerTask.new(timer_task_options) do
    with_logging_context do
      redis do |conn|
        refresh_reaper_mutex
        Orphans::Reaper.call(conn)
      end
    end
  end
end

def disabled?
  !enabled?
end

def drift_reaper_interval
  reaper_interval + (reaper_interval * DRIFT_FACTOR).to_i
end

def enabled?
  REAPERS.include?(reaper)
end

def logging_context
  if logger_context_hash?
    { "uniquejobs" => "reaper" }
  else
    "uniquejobs=orphan-reaper"
  end
end

def reaper
  SidekiqUniqueJobs.config.reaper
end

def reaper_interval
  SidekiqUniqueJobs.config.reaper_interval
end

def reaper_timeout
  SidekiqUniqueJobs.config.reaper_timeout
end

def refresh_reaper_mutex
  redis { |conn| conn.set(UNIQUE_REAPER, current_timestamp, ex: drift_reaper_interval) }
end

def register_reaper_process
  redis { |conn| conn.set(UNIQUE_REAPER, current_timestamp, nx: true, ex: drift_reaper_interval) }
end

def registered?
  redis do |conn|
    conn.get(UNIQUE_REAPER).to_i + drift_reaper_interval > current_timestamp
  end
end

def start(test_task = nil) # rubocop:disable
  return if disabled?
  return if registered?
  self.task = test_task || default_task
  with_logging_context do
    register_reaper_process
    log_info("Starting Reaper")
    task.add_observer(Observer.new)
    task.execute
    task
  end
end

def stop
  return if disabled?
  return if unregistered?
  with_logging_context do
    log_info("Stopping Reaper")
    unregister_reaper_process
    task.shutdown
  end
end

def task
  @task ||= default_task
end

def task=(task)
  @task = task
end

def timer_task_options
  { run_now: true,
    execution_interval: reaper_interval,
    timeout_interval: reaper_timeout }
end

def unregister_reaper_process
  redis { |conn| conn.del(UNIQUE_REAPER) }
end

def unregistered?
  !registered?
end