class SplitIoClient::Cache::Adapters::RedisAdapter

def add_to_map(key, field, value)
  @redis.hset(key, field, value)
end

def add_to_queue(key, val)
  @redis.rpush(key, val)
end

def add_to_set(key, val)
  @redis.sadd?(key, val)
end

def append_to_string(key, val)
  @redis.append(key, val)
end

def bool(key)
  @redis.get(key) == 'true'
end

def clear(prefix)
  # noop
end

def delete(key)
  return nil if key == []
  @redis.del(key)
end

def delete_from_map(key, field)
  @redis.hdel(key, field)
end

def delete_from_set(key, val)
  @redis.srem(key, val)
end

def exists?(key)
  @redis.exists?(key)
end

def expire(key, seconds)
  @redis.expire(key, seconds)
end

def find_in_map(key, field)
  @redis.hget(key, field)
end

def find_strings_by_pattern(pattern)
  memo = { items: [], cursor: 0 }
  loop do
    memo[:cursor], items = @redis.scan(memo[:cursor], match: "#{pattern}", count: SCAN_SLICE)
    memo[:items].push(*items)
    break if memo[:cursor] == '0'
  end
  memo[:items]
end

def find_strings_by_prefix(prefix)
  find_strings_by_pattern("#{prefix}*")
end

def get_all_from_set(key)
  @redis.smembers(key)
end

def get_from_queue(key, count)
  items = @redis.lrange(key, 0, count - 1)
  fetched_count = items.size
  items_to_remove = fetched_count == count ? count : fetched_count
  @redis.ltrim(key, items_to_remove, -1)
  items
end

def get_map(key)
  @redis.hgetall(key)
end

def get_set(key)
  @redis.smembers(key)
end

def hincrby(key, field, increment)
  @redis.hincrby(key, field, increment)
end

def in_map?(key, field)
  @redis.hexists(key, field)
end

def in_set?(key, val)
  @redis.sismember(key, val)
end

def inc(key, inc = 1)
  @redis.incrby(key, inc)
end

def initialize(redis_url)
  connection = redis_url.is_a?(Hash) ? redis_url : { url: redis_url }
  @redis = Redis.new(connection)
end

def initialize_map(key)
  # No need to initialize hash/map in Redis
end

def map_keys(key)
  @redis.hkeys(key)
end

def multiple_strings(keys)
  Hash[keys.zip(@redis.mget(keys))]
end

def pipelined
  @redis.pipelined do |pipeline|
    yield
  end
end

def random_set_elements(key, count)
  @redis.srandmember(key, count)
end

def set_bool(key, val)
  @redis.set(key, val.to_s)
end

def set_string(key, str)
  @redis.set(key, str)
end

def string(key)
  @redis.get(key)
end

def union_sets(set_keys)
  return [] if set_keys == []
  @redis.sunion(set_keys)
end