class Redis

# File lib/redis.rb, line 39
def current
  deprecate!("`Redis.current=` is deprecated and will be removed in 5.0. (called from: #{caller(1, 1).first})")
  @current ||= Redis.new
end

# File lib/redis.rb, line 44
def current=(redis)
  deprecate!("`Redis.current=` is deprecated and will be removed in 5.0. (called from: #{caller(1, 1).first})")
  @current = redis
end

# File lib/redis.rb, line 29
def deprecate!(message)
  unless silence_deprecations
    if raise_deprecations
      raise Deprecated, message
    else
      ::Kernel.warn(message)
    end
  end
end

# File lib/redis.rb, line 17
def exists_returns_integer=(value)
  unless value
    deprecate!(
      "`Redis#exists(key)` will return an Integer by default in redis-rb 4.3. The option to explicitly " \
      "disable this behaviour via `Redis.exists_returns_integer` will be removed in 5.0. You should use " \
      "`exists?` instead."
    )
  end

  @exists_returns_integer = value
end

# File lib/redis.rb, line 80
def initialize(options = {})
  @options = options.dup
  @cluster_mode = options.key?(:cluster)
  client = @cluster_mode ? Cluster : Client
  @original_client = @client = client.new(options)
  @queue = Hash.new { |h, k| h[k] = [] }
  @monitor = Monitor.new
end

# File lib/redis.rb, line 153
def _client
  @client
end

# File lib/redis.rb, line 107
def close
  @original_client.disconnect
end

# File lib/redis.rb, line 133
def commit
  ::Redis.deprecate!(
    "Redis#commit is deprecated and will be removed in Redis 5.0.0. Use Redis#pipelined instead. " \
    "(called from: #{Kernel.caller(1, 1).first})"
  )

  synchronize do |client|
    begin
      pipeline = Pipeline.new(client)
      @queue[Thread.current.object_id].each do |command|
        pipeline.call(command)
      end

      client.call_pipelined(pipeline)
    ensure
      @queue.delete(Thread.current.object_id)
    end
  end
end

# File lib/redis.rb, line 102
def connected?
  @original_client.connected?
end

# File lib/redis.rb, line 243
def connection
  return @original_client.connection_info if @cluster_mode

  {
    host: @original_client.host,
    port: @original_client.port,
    db: @original_client.db,
    id: @original_client.id,
    location: @original_client.location
  }
end

# File lib/redis.rb, line 239
def dup
  self.class.new(@options)
end

# File lib/redis.rb, line 231
def id
  @original_client.id
end

# File lib/redis.rb, line 235
def inspect
  "#<Redis client v#{Redis::VERSION} for #{id}>"
end

# File lib/redis.rb, line 207
def multi(&block)
  if block_given?
    deprecation_displayed = false
    if block&.arity == 0
      Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 5))
      deprecation_displayed = true
    end

    synchronize do |prior_client|
      begin
        pipeline = Pipeline::Multi.new(prior_client)
        @client = deprecation_displayed ? pipeline : DeprecatedMulti.new(pipeline)
        pipelined_connection = PipelinedConnection.new(pipeline)
        yield pipelined_connection
        prior_client.call_pipeline(pipeline)
      ensure
        @client = prior_client
      end
    end
  else
    send_command([:multi])
  end
end

# File lib/redis.rb, line 157
def pipelined(&block)
  deprecation_displayed = false
  if block&.arity == 0
    Pipeline.deprecation_warning("pipelined", Kernel.caller_locations(1, 5))
    deprecation_displayed = true
  end

  synchronize do |prior_client|
    begin
      pipeline = Pipeline.new(prior_client)
      @client = deprecation_displayed ? pipeline : DeprecatedPipeline.new(pipeline)
      pipelined_connection = PipelinedConnection.new(pipeline)
      yield pipelined_connection
      prior_client.call_pipeline(pipeline)
    ensure
      @client = prior_client
    end
  end
end

# File lib/redis.rb, line 118
def queue(*command)
  ::Redis.deprecate!(
    "Redis#queue is deprecated and will be removed in Redis 5.0.0. Use Redis#pipelined instead." \
    "(called from: #{caller(1, 1).first})"
  )

  synchronize do
    @queue[Thread.current.object_id] << command
  end
end

# File lib/redis.rb, line 90
def with_reconnect(val = true, &blk)
  synchronize do |client|
    client.with_reconnect(val, &blk)
  end
end

# File lib/redis.rb, line 97
def without_reconnect(&blk)
  with_reconnect(false, &blk)
end

# File lib/redis.rb, line 273
def _subscription(method, timeout, channels, block)
  return @client.call([method] + channels) if subscribed?

  begin
    original, @client = @client, SubscribedClient.new(@client)
    if timeout > 0
      @client.send(method, timeout, *channels, &block)
    else
      @client.send(method, *channels, &block)
    end
  ensure
    @client = original
  end
end

# File lib/redis.rb, line 267
def send_blocking_command(command, timeout, &block)
  @monitor.synchronize do
    @client.call_with_timeout(command, timeout, &block)
  end
end

# File lib/redis.rb, line 261
def send_command(command, &block)
  @monitor.synchronize do
    @client.call(command, &block)
  end
end

# File lib/redis.rb, line 257
def synchronize
  @monitor.synchronize { yield(@client) }
end