class SidekiqUniqueJobs::Lock::BaseLock

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

def call_strategy
  @attempt += 1
  client_strategy.call { lock if replace? }
end

def callback_safely
  callback&.call
  item[JID]
rescue StandardError
  log_warn("unlocked successfully but the #after_unlock callback failed!")
  raise
end

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

def delete
  locksmith.delete # Soft delete (don't forcefully remove when expiration is set)
end

def delete!
  locksmith.delete! # Force delete the lock
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(&block)
  return call_strategy unless (locked_token = locksmith.lock(&block))
  locked_token
end

def locked?
  locksmith.locked?
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 replace?
  client_strategy.replace? && attempt < 2
end

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

def unlock
  locksmith.unlock # Only signal to release the lock
end

def unlock_with_callback
  return log_warn("might need to be unlocked manually") unless unlock
  callback_safely
  item[JID]
end