class SidekiqUniqueJobs::Lock::BaseLock

def self.validate_options(options = {})
  Validator.validate(options)
end

def call_strategy(origin:)
  new_job_id = nil
  strategy   = strategy_for(origin)
  @attempt  += 1
  strategy.call { new_job_id = lock if strategy.replace? && @attempt < 2 }
  yield if new_job_id && block_given?
end

def callback_safely
  callback&.call
  item[JID]
rescue StandardError
  reflect(:after_unlock_callback_failed, item)
  raise
end

def client_strategy
  @client_strategy ||=
    OnConflict.find_strategy(lock_config.on_client_conflict).new(item, redis_pool)
end

def execute
  raise NotImplementedError, "##{__method__} needs to be implemented in #{self.class}"
end

def initialize(item, callback, redis_pool = nil)
  @item       = item
  @callback   = callback
  @redis_pool = redis_pool
  @attempt    = 0
  prepare_item # Used to ease testing
  @lock_config = LockConfig.new(item)
end

def lock
  raise NotImplementedError, "##{__method__} needs to be implemented in #{self.class}"
end

def locksmith
  @locksmith ||= SidekiqUniqueJobs::Locksmith.new(item, redis_pool)
end

def prepare_item
  return if item.key?(LOCK_DIGEST)
  # The below should only be done to ease testing
  # in production this will be done by the middleware
  SidekiqUniqueJobs::Job.prepare(item)
end

def server_strategy
  @server_strategy ||=
    OnConflict.find_strategy(lock_config.on_server_conflict).new(item, redis_pool)
end

def strategy_for(origin)
  case origin
  when :client
    client_strategy
  when :server
    server_strategy
  else
    raise SidekiqUniqueJobs::InvalidArgument,
      "#origin needs to be either `:server` or `:client`"
  end
end

def unlock_and_callback
  return callback_safely if locksmith.unlock
  reflect(:unlock_failed, item)
end