module Redis::Commands::Lists

def _bpop(cmd, args, &blk)
  timeout = if args.last.is_a?(Hash)
    options = args.pop
    options[:timeout]
  end
  timeout ||= 0
  unless timeout.is_a?(Integer) || timeout.is_a?(Float)
    raise ArgumentError, "timeout must be an Integer or Float, got: #{timeout.class}"
  end
  args.flatten!(1)
  command = [cmd].concat(args)
  command << timeout
  send_blocking_command(command, timeout, &blk)
end

def _normalize_move_wheres(where_source, where_destination)
  where_source      = where_source.to_s.upcase
  where_destination = where_destination.to_s.upcase
  if where_source != "LEFT" && where_source != "RIGHT"
    raise ArgumentError, "where_source must be 'LEFT' or 'RIGHT'"
  end
  if where_destination != "LEFT" && where_destination != "RIGHT"
    raise ArgumentError, "where_destination must be 'LEFT' or 'RIGHT'"
  end
  [where_source, where_destination]
end

def blmove(source, destination, where_source, where_destination, timeout: 0)
  where_source, where_destination = _normalize_move_wheres(where_source, where_destination)
  command = [:blmove, source, destination, where_source, where_destination, timeout]
  send_blocking_command(command, timeout)
end

def blmpop(timeout, *keys, modifier: "LEFT", count: nil)
  raise ArgumentError, "Pick either LEFT or RIGHT" unless modifier == "LEFT" || modifier == "RIGHT"
  args = [:blmpop, timeout, keys.size, *keys, modifier]
  args << "COUNT" << Integer(count) if count
  send_blocking_command(args, timeout)
end

def blpop(*args)
  _bpop(:blpop, args)
end

def brpop(*args)
  _bpop(:brpop, args)
end

def brpoplpush(source, destination, timeout: 0)
  command = [:brpoplpush, source, destination, timeout]
  send_blocking_command(command, timeout)
end

def lindex(key, index)
  send_command([:lindex, key, Integer(index)])
end

def linsert(key, where, pivot, value)
  send_command([:linsert, key, where, pivot, value])
end

def llen(key)
  send_command([:llen, key])
end

def lmove(source, destination, where_source, where_destination)
  where_source, where_destination = _normalize_move_wheres(where_source, where_destination)
  send_command([:lmove, source, destination, where_source, where_destination])
end

def lmpop(*keys, modifier: "LEFT", count: nil)
  raise ArgumentError, "Pick either LEFT or RIGHT" unless modifier == "LEFT" || modifier == "RIGHT"
  args = [:lmpop, keys.size, *keys, modifier]
  args << "COUNT" << Integer(count) if count
  send_command(args)
end

def lpop(key, count = nil)
  command = [:lpop, key]
  command << Integer(count) if count
  send_command(command)
end

def lpush(key, value)
  send_command([:lpush, key, value])
end

def lpushx(key, value)
  send_command([:lpushx, key, value])
end

def lrange(key, start, stop)
  send_command([:lrange, key, Integer(start), Integer(stop)])
end

def lrem(key, count, value)
  send_command([:lrem, key, Integer(count), value])
end

def lset(key, index, value)
  send_command([:lset, key, Integer(index), value])
end

def ltrim(key, start, stop)
  send_command([:ltrim, key, Integer(start), Integer(stop)])
end

def rpop(key, count = nil)
  command = [:rpop, key]
  command << Integer(count) if count
  send_command(command)
end

def rpoplpush(source, destination)
  send_command([:rpoplpush, source, destination])
end

def rpush(key, value)
  send_command([:rpush, key, value])
end

def rpushx(key, value)
  send_command([:rpushx, key, value])
end