//ZINTERSTORE destination numkeys key
func (r *RedisType) ZInterStore(destination, key string, numkeys int, weight ...interface{}) (int, error) {
	if len(weight) > 0 {
		row, err := redis.Int(r.RedisConn.Do("ZINTERSTORE", destination, key, numkeys, weight))
		return row, err
	}
	row, err := redis.Int(r.RedisConn.Do("ZINTERSTORE", destination, key, numkeys))
	return row, err
}

func (r *RedisType) BitPos(key string, bit int, borders ...int) (int, error) {
	if len(borders) > 0 {
		if len(borders) > 1 {
			return 0, errors.New("Too many borders")
		}
		row, err := redis.Int(r.RedisConn.Do("BITPOS", key, bit, borders[0], borders[1]))
		return row, err
	} else {
		row, err := redis.Int(r.RedisConn.Do("BITPOS", key, bit))
		return row, err
	}
}

func (r *RedisType) ZRevRank(key, member string) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("ZREVRANK", key, member))
	if err == redis.ErrNil {
		return 0, nil
	}
	return row, err
}

func (r *RedisType) ZCard(key string) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("ZCARD", key))
	if err == redis.ErrNil {
		return 0, nil
	}
	return row, err
}

func (r *RedisType) ZCount(key string, min, max int) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("ZCOUNT", key, min, max))
	if err == redis.ErrNil {
		return 0, nil
	}
	return row, err
}

func (r *RedisType) Ttl(key string) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("TTL", key))
	if row < 0 {
		row = 0
	}
	return row, err
}

func (r *RedisType) SRem(key string, members ...interface{}) (int, error) {
	params := make([]interface{}, 0)
	params = append(params, key)
	for _, v := range members {
		params = append(params, v)
	}
	row, err := redis.Int(r.RedisConn.Do("SREM", params...))
	return row, err
}

func (r *RedisType) PfAdd(key string, element ...interface{}) (int, error) {
	params := make([]interface{}, 0)
	params = append(params, key)
	for _, v := range element {
		params = append(params, v)
	}
	row, err := redis.Int(r.RedisConn.Do("PFADD", params))
	return row, err
}

func (r *RedisType) ZScore(key, member string) (interface{}, error) {
	params := make([]interface{}, 0)
	params = append(params, key)
	params = append(params, member)
	row, err := redis.Int(r.RedisConn.Do("ZSCORE", params...))
	if err == redis.ErrNil {
		return nil, nil
	}
	return row, err
}

func (r *RedisType) ZUnionStore(destination string, numkeys int, key interface{}, weights ...interface{}) (interface{}, error) {
	params := make([]interface{}, 0)
	params = append(params, destination)
	params = append(params, numkeys)
	switch key.(type) {
	case string:
		params = append(params, key)
	case []string:
		for _, v := range key.([]string) {
			params = append(params, v)
		}
	}
	if len(weights) > 0 {
		for _, v := range weights {
			params = append(params, v)
		}
	}
	row, err := redis.Int(r.RedisConn.Do("ZUNIONSTORE", params...))
	if err == redis.ErrNil {
		return nil, nil
	}
	return row, err
}

func (r *RedisType) SMove(source, destination string, member interface{}) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("SMOVE", source, destination, member))
	return row, err
}

func (r *RedisType) SInterScore(destination string, key ...interface{}) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("SINTERSTORE", destination, key))
	return row, err
}

func (r *RedisType) SCard(key string) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("SCARD", key))
	return row, err
}

//zlexcount key min max
func (r *RedisType) ZLexCount(key string, min, max int) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("ZLEXCOUNT", key, min, max))
	return row, err
}

func (r *RedisType) DecrBy(key string, decrement interface{}) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("DECRBY", key, decrement))
	return row, err
}

func (r *RedisType) Publish(channel string, message interface{}) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("PUBLISH", channel, message))
	return row, err
}

func (r *RedisType) Expire(key string, seconds uint32) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("EXPIRE", key, seconds))
	return row, err
}

func (r *RedisType) Append(key string, value interface{}) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("APPEND", key, value))
	return row, err
}

func (r *RedisType) StrLen(key string) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("STRLEN", key))
	return row, err
}

func (r *RedisType) ExpireAt(key string, timestamp uint32) (int, error) {
	row, err := redis.Int(r.RedisConn.Do("EXPIREAT", key, timestamp))
	return row, err
}