class SidekiqUniqueJobs::Lock

def self.create(digest, job_id, lock_info = {})
  lock = new(digest, time: Timing.now_f)
  lock.lock(job_id, lock_info)
  lock
end

def all_jids
  (queued_jids + primed_jids + locked_jids).uniq
end

def changelog
  @changelog ||= Changelog.new
end

def changelog_json(job_id, script, message)
  dump_json(
    digest: key.digest,
    job_id: job_id,
    script: script,
    message: message,
    time: now_f,
  )
end

def changelogs
  changelog.entries(pattern: "*#{key.digest}*")
end

def created_at
  @created_at ||= changelogs.first&.[]("time")
end

def del
  redis do |conn|
    conn.multi do
      conn.zrem(DIGESTS, key.digest)
      conn.del(key.digest, key.queued, key.primed, key.locked, key.info)
    end
  end
end

def digest
  @digest ||= Redis::String.new(key.digest)
end

def get_key(key)
  if key.is_a?(SidekiqUniqueJobs::Key)
    key
  else
    SidekiqUniqueJobs::Key.new(key)
  end
end

def info
  @info ||= LockInfo.new(key.info)
end

def initialize(key, time: nil)
  @key        = get_key(key)
  @created_at = time.is_a?(Float) ? time : time.to_f
end

def inspect
  to_s
end

def lock(job_id, lock_info = {})
  redis do |conn|
    conn.multi do
      conn.set(key.digest, job_id)
      conn.hset(key.locked, job_id, now_f)
      info.set(lock_info)
      conn.zadd(key.digests, now_f, key.digest)
      conn.zadd(key.changelog, now_f, changelog_json(job_id, "queue.lua", "Queued"))
      conn.zadd(key.changelog, now_f, changelog_json(job_id, "lock.lua", "Locked"))
    end
  end
end

def locked
  @locked ||= Redis::Hash.new(key.locked)
end

def locked_jids(with_values: false)
  locked.entries(with_values: with_values)
end

def primed
  @primed ||= Redis::List.new(key.primed)
end

def primed_jids
  primed.entries
end

def queued
  @queued ||= Redis::List.new(key.queued)
end

def queued_jids
  queued.entries
end

def to_s
  <<~MESSAGE
    Lock status for #{key}
              value: #{digest.value}
               info: #{info.value}
        queued_jids: #{queued_jids}
        primed_jids: #{primed_jids}
        locked_jids: #{locked_jids}
         changelogs: #{changelogs}
  MESSAGE
end

def unlock(job_id)
  locked.del(job_id)
end