class RedisSet

# File lib/redis_set.rb, line 11
def initialize(name, redis_or_options = {}, more_options = {})
        name = name.to_s if name.kind_of? Symbol

        raise InvalidNameException.new unless name.kind_of?(String) && name.size > 0
        @name = name
        @redis = if redis_or_options.kind_of?(Redis)
                         redis_or_options
                       elsif redis_or_options.kind_of? Hash
                               ::Redis.new redis_or_options
                       elsif defined?(ActiveSupport::Cache::RedisStore) && redis_or_options.kind_of?(ActiveSupport::Cache::RedisStore)
                               @pooled = redis_or_options.data.kind_of?(ConnectionPool)
                               redis_or_options.data
                       elsif defined?(ConnectionPool) && redis_or_options.kind_of?(ConnectionPool)
                               @pooled = true
                               redis_or_options
                       else
                               raise InvalidRedisConfigException.new
                 end

        if more_options.kind_of?(Hash) && more_options[:expire]
                expire more_options[:expire]
        end
end

# File lib/redis_set.rb, line 35
def add *values
        values = [values].flatten
        with{|redis| redis.sadd name, values} if values.size > 0
end

# File lib/redis_set.rb, line 42
def add_with_count value
        block_on_atomic_attempt { attempt_atomic_add_read_count value }
end

# File lib/redis_set.rb, line 67
def all
        with{|redis| redis.smembers name}
end

# File lib/redis_set.rb, line 104
def clear
        with{|redis| redis.del name}
        []
end

# File lib/redis_set.rb, line 91
def enumerator(slice_size = 10)
        cursor = 0
        Enumerator.new do |yielder|
                loop do
                        cursor, items = scan cursor, slice_size
                        items.each do |item|
                                yielder << item
                        end
                        raise StopIteration if cursor.to_i.zero?
                end
        end
end

# File lib/redis_set.rb, line 111
def expire seconds
        with{|redis| redis.expire name, seconds.to_i}
end

# File lib/redis_set.rb, line 57
def include? value
        with{|redis| redis.sismember(name, value)}
end

# File lib/redis_set.rb, line 71
def intersection *sets
        sets = [sets].flatten
        if sets.size >= 1
                sets = sets.map do |s|
                        if s.kind_of?(self.class)
                                s.name
                        else
                                s
                        end
                end
                sets << name

                with{|redis| redis.sinter *sets }
        end
end

# File lib/redis_set.rb, line 53
def pop(amount = 1)
        with{|redis| redis.spop name, amount}
end

# File lib/redis_set.rb, line 48
def remove *values
        values = [values].flatten
        with{|redis|redis.srem name, values} if values.size > 0
end

# File lib/redis_set.rb, line 87
def scan cursor = 0, amount = 10, match = "*"
        with{|redis| redis.sscan name, cursor, :count => amount, :match => match}
end

# File lib/redis_set.rb, line 61
def size
        with{|redis| redis.scard name}
end

# File lib/redis_set.rb, line 117
def attempt_atomic_add_read_count value
        attempt_atomic_write_read lambda { add value }, lambda { |multi, read_result| multi.scard name }
end

# File lib/redis_set.rb, line 129
def attempt_atomic_write_read write_op, read_op
        success, write_result, read_result = false, nil, nil

        with do |redis|
                success = redis.watch(name) do
                        write_result = write_op.call
                        #if write_result
                        redis.multi do |multi|
                                read_result = read_op.call multi, write_result
                        end
                        #end
                end
        end

        [success, read_result]
end

# File lib/redis_set.rb, line 121
def block_on_atomic_attempt
        begin
                success, result = yield
                #puts "success is #{success} and result is #{result}"
        end while !success && result
        result.value
end

# File lib/redis_set.rb, line 154
def pooled?
        !!@pooled
end

# File lib/redis_set.rb, line 146
def with(&block)
        if pooled?
                @redis.with(&block)
        else
                block.call(@redis)
        end
end