package redis

import "context"

type ACLCmdable interface {
        ACLDryRun(ctx context.Context, username string, command ...interface{}) *StringCmd

        ACLLog(ctx context.Context, count int64) *ACLLogCmd
        ACLLogReset(ctx context.Context) *StatusCmd

        ACLSetUser(ctx context.Context, username string, rules ...string) *StatusCmd
        ACLDelUser(ctx context.Context, username string) *IntCmd
        ACLList(ctx context.Context) *StringSliceCmd

        ACLCat(ctx context.Context) *StringSliceCmd
        ACLCatArgs(ctx context.Context, options *ACLCatArgs) *StringSliceCmd
}

type ACLCatArgs struct {
        Category string
}

func (c cmdable) ACLDryRun(ctx context.Context, username string, command ...interface{}) *StringCmd {
        args := make([]interface{}, 0, 3+len(command))
        args = append(args, "acl", "dryrun", username)
        args = append(args, command...)
        cmd := NewStringCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ACLLog(ctx context.Context, count int64) *ACLLogCmd {
        args := make([]interface{}, 0, 3)
        args = append(args, "acl", "log")
        if count > 0 {
                args = append(args, count)
        }
        cmd := NewACLLogCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ACLLogReset(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "acl", "log", "reset")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ACLDelUser(ctx context.Context, username string) *IntCmd {
        cmd := NewIntCmd(ctx, "acl", "deluser", username)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ACLSetUser(ctx context.Context, username string, rules ...string) *StatusCmd {
        args := make([]interface{}, 3+len(rules))
        args[0] = "acl"
        args[1] = "setuser"
        args[2] = username
        for i, rule := range rules {
                args[i+3] = rule
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ACLList(ctx context.Context) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "acl", "list")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ACLCat(ctx context.Context) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "acl", "cat")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ACLCatArgs(ctx context.Context, options *ACLCatArgs) *StringSliceCmd {
        // if there is a category passed, build new cmd, if there isn't - use the ACLCat method
        if options != nil && options.Category != "" {
                cmd := NewStringSliceCmd(ctx, "acl", "cat", options.Category)
                _ = c(ctx, cmd)
                return cmd
        }

        return c.ACLCat(ctx)
}

// Package auth package provides authentication-related interfaces and types.
// It also includes a basic implementation of credentials using username and password.
package auth

// StreamingCredentialsProvider is an interface that defines the methods for a streaming credentials provider.
// It is used to provide credentials for authentication.
// The CredentialsListener is used to receive updates when the credentials change.
type StreamingCredentialsProvider interface {
        // Subscribe subscribes to the credentials provider for updates.
        // It returns the current credentials, a cancel function to unsubscribe from the provider,
        // and an error if any.
        // TODO(ndyakov): Should we add context to the Subscribe method?
        Subscribe(listener CredentialsListener) (Credentials, UnsubscribeFunc, error)
}

// UnsubscribeFunc is a function that is used to cancel the subscription to the credentials provider.
// It is used to unsubscribe from the provider when the credentials are no longer needed.
type UnsubscribeFunc func() error

// CredentialsListener is an interface that defines the methods for a credentials listener.
// It is used to receive updates when the credentials change.
// The OnNext method is called when the credentials change.
// The OnError method is called when an error occurs while requesting the credentials.
type CredentialsListener interface {
        OnNext(credentials Credentials)
        OnError(err error)
}

// Credentials is an interface that defines the methods for credentials.
// It is used to provide the credentials for authentication.
type Credentials interface {
        // BasicAuth returns the username and password for basic authentication.
        BasicAuth() (username string, password string)
        // RawCredentials returns the raw credentials as a string.
        // This can be used to extract the username and password from the raw credentials or
        // additional information if present in the token.
        RawCredentials() string
}

type basicAuth struct {
        username string
        password string
}

// RawCredentials returns the raw credentials as a string.
func (b *basicAuth) RawCredentials() string {
        return b.username + ":" + b.password
}

// BasicAuth returns the username and password for basic authentication.
func (b *basicAuth) BasicAuth() (username string, password string) {
        return b.username, b.password
}

// NewBasicCredentials creates a new Credentials object from the given username and password.
func NewBasicCredentials(username, password string) Credentials {
        return &basicAuth{
                username: username,
                password: password,
        }
}

package auth

// ReAuthCredentialsListener is a struct that implements the CredentialsListener interface.
// It is used to re-authenticate the credentials when they are updated.
// It contains:
// - reAuth: a function that takes the new credentials and returns an error if any.
// - onErr: a function that takes an error and handles it.
type ReAuthCredentialsListener struct {
        reAuth func(credentials Credentials) error
        onErr  func(err error)
}

// OnNext is called when the credentials are updated.
// It calls the reAuth function with the new credentials.
// If the reAuth function returns an error, it calls the onErr function with the error.
func (c *ReAuthCredentialsListener) OnNext(credentials Credentials) {
        if c.reAuth == nil {
                return
        }

        err := c.reAuth(credentials)
        if err != nil {
                c.OnError(err)
        }
}

// OnError is called when an error occurs.
// It can be called from both the credentials provider and the reAuth function.
func (c *ReAuthCredentialsListener) OnError(err error) {
        if c.onErr == nil {
                return
        }

        c.onErr(err)
}

// NewReAuthCredentialsListener creates a new ReAuthCredentialsListener.
// Implements the auth.CredentialsListener interface.
func NewReAuthCredentialsListener(reAuth func(credentials Credentials) error, onErr func(err error)) *ReAuthCredentialsListener {
        return &ReAuthCredentialsListener{
                reAuth: reAuth,
                onErr:  onErr,
        }
}

// Ensure ReAuthCredentialsListener implements the CredentialsListener interface.
var _ CredentialsListener = (*ReAuthCredentialsListener)(nil)

package redis

import (
        "context"
        "errors"
)

type BitMapCmdable interface {
        GetBit(ctx context.Context, key string, offset int64) *IntCmd
        SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd
        BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd
        BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd
        BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd
        BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd
        BitOpDiff(ctx context.Context, destKey string, keys ...string) *IntCmd
        BitOpDiff1(ctx context.Context, destKey string, keys ...string) *IntCmd
        BitOpAndOr(ctx context.Context, destKey string, keys ...string) *IntCmd
        BitOpOne(ctx context.Context, destKey string, keys ...string) *IntCmd
        BitOpNot(ctx context.Context, destKey string, key string) *IntCmd
        BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd
        BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *IntCmd
        BitField(ctx context.Context, key string, values ...interface{}) *IntSliceCmd
        BitFieldRO(ctx context.Context, key string, values ...interface{}) *IntSliceCmd
}

func (c cmdable) GetBit(ctx context.Context, key string, offset int64) *IntCmd {
        cmd := NewIntCmd(ctx, "getbit", key, offset)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd {
        cmd := NewIntCmd(
                ctx,
                "setbit",
                key,
                offset,
                value,
        )
        _ = c(ctx, cmd)
        return cmd
}

type BitCount struct {
        Start, End int64
        Unit       string // BYTE(default) | BIT
}

const BitCountIndexByte string = "BYTE"
const BitCountIndexBit string = "BIT"

func (c cmdable) BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd {
        args := make([]any, 2, 5)
        args[0] = "bitcount"
        args[1] = key
        if bitCount != nil {
                args = append(args, bitCount.Start, bitCount.End)
                if bitCount.Unit != "" {
                        if bitCount.Unit != BitCountIndexByte && bitCount.Unit != BitCountIndexBit {
                                cmd := NewIntCmd(ctx)
                                cmd.SetErr(errors.New("redis: invalid bitcount index"))
                                return cmd
                        }
                        args = append(args, bitCount.Unit)
                }
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) bitOp(ctx context.Context, op, destKey string, keys ...string) *IntCmd {
        args := make([]interface{}, 3+len(keys))
        args[0] = "bitop"
        args[1] = op
        args[2] = destKey
        for i, key := range keys {
                args[3+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BitOpAnd creates a new bitmap in which users are members of all given bitmaps
func (c cmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd {
        return c.bitOp(ctx, "and", destKey, keys...)
}

// BitOpOr creates a new bitmap in which users are member of at least one given bitmap
func (c cmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd {
        return c.bitOp(ctx, "or", destKey, keys...)
}

// BitOpXor creates a new bitmap in which users are the result of XORing all given bitmaps
func (c cmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd {
        return c.bitOp(ctx, "xor", destKey, keys...)
}

// BitOpNot creates a new bitmap in which users are not members of a given bitmap
func (c cmdable) BitOpNot(ctx context.Context, destKey string, key string) *IntCmd {
        return c.bitOp(ctx, "not", destKey, key)
}

// BitOpDiff creates a new bitmap in which users are members of bitmap X but not of any of bitmaps Y1, Y2, …
// Introduced with Redis 8.2
func (c cmdable) BitOpDiff(ctx context.Context, destKey string, keys ...string) *IntCmd {
        return c.bitOp(ctx, "diff", destKey, keys...)
}

// BitOpDiff1 creates a new bitmap in which users are members of one or more of bitmaps Y1, Y2, … but not members of bitmap X
// Introduced with Redis 8.2
func (c cmdable) BitOpDiff1(ctx context.Context, destKey string, keys ...string) *IntCmd {
        return c.bitOp(ctx, "diff1", destKey, keys...)
}

// BitOpAndOr creates a new bitmap in which users are members of bitmap X and also members of one or more of bitmaps Y1, Y2, …
// Introduced with Redis 8.2
func (c cmdable) BitOpAndOr(ctx context.Context, destKey string, keys ...string) *IntCmd {
        return c.bitOp(ctx, "andor", destKey, keys...)
}

// BitOpOne creates a new bitmap in which users are members of exactly one of the given bitmaps
// Introduced with Redis 8.2
func (c cmdable) BitOpOne(ctx context.Context, destKey string, keys ...string) *IntCmd {
        return c.bitOp(ctx, "one", destKey, keys...)
}

// BitPos is an API before Redis version 7.0, cmd: bitpos key bit start end
// if you need the `byte | bit` parameter, please use `BitPosSpan`.
func (c cmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd {
        args := make([]interface{}, 3+len(pos))
        args[0] = "bitpos"
        args[1] = key
        args[2] = bit
        switch len(pos) {
        case 0:
        case 1:
                args[3] = pos[0]
        case 2:
                args[3] = pos[0]
                args[4] = pos[1]
        default:
                panic("too many arguments")
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BitPosSpan supports the `byte | bit` parameters in redis version 7.0,
// the bitpos command defaults to using byte type for the `start-end` range,
// which means it counts in bytes from start to end. you can set the value
// of "span" to determine the type of `start-end`.
// span = "bit", cmd: bitpos key bit start end bit
// span = "byte", cmd: bitpos key bit start end byte
func (c cmdable) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *IntCmd {
        cmd := NewIntCmd(ctx, "bitpos", key, bit, start, end, span)
        _ = c(ctx, cmd)
        return cmd
}

// BitField accepts multiple values:
//   - BitField("set", "i1", "offset1", "value1","cmd2", "type2", "offset2", "value2")
//   - BitField([]string{"cmd1", "type1", "offset1", "value1","cmd2", "type2", "offset2", "value2"})
//   - BitField([]interface{}{"cmd1", "type1", "offset1", "value1","cmd2", "type2", "offset2", "value2"})
func (c cmdable) BitField(ctx context.Context, key string, values ...interface{}) *IntSliceCmd {
        args := make([]interface{}, 2, 2+len(values))
        args[0] = "bitfield"
        args[1] = key
        args = appendArgs(args, values)
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BitFieldRO - Read-only variant of the BITFIELD command.
// It is like the original BITFIELD but only accepts GET subcommand and can safely be used in read-only replicas.
// - BitFieldRO(ctx, key, "<Encoding0>", "<Offset0>", "<Encoding1>","<Offset1>")
func (c cmdable) BitFieldRO(ctx context.Context, key string, values ...interface{}) *IntSliceCmd {
        args := make([]interface{}, 2, 2+len(values))
        args[0] = "BITFIELD_RO"
        args[1] = key
        if len(values)%2 != 0 {
                panic("BitFieldRO: invalid number of arguments, must be even")
        }
        for i := 0; i < len(values); i += 2 {
                args = append(args, "GET", values[i], values[i+1])
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import "context"

type ClusterCmdable interface {
        ClusterMyShardID(ctx context.Context) *StringCmd
        ClusterMyID(ctx context.Context) *StringCmd
        ClusterSlots(ctx context.Context) *ClusterSlotsCmd
        ClusterShards(ctx context.Context) *ClusterShardsCmd
        ClusterLinks(ctx context.Context) *ClusterLinksCmd
        ClusterNodes(ctx context.Context) *StringCmd
        ClusterMeet(ctx context.Context, host, port string) *StatusCmd
        ClusterForget(ctx context.Context, nodeID string) *StatusCmd
        ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd
        ClusterResetSoft(ctx context.Context) *StatusCmd
        ClusterResetHard(ctx context.Context) *StatusCmd
        ClusterInfo(ctx context.Context) *StringCmd
        ClusterKeySlot(ctx context.Context, key string) *IntCmd
        ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd
        ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd
        ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd
        ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd
        ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd
        ClusterSaveConfig(ctx context.Context) *StatusCmd
        ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd
        ClusterFailover(ctx context.Context) *StatusCmd
        ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd
        ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd
        ReadOnly(ctx context.Context) *StatusCmd
        ReadWrite(ctx context.Context) *StatusCmd
}

func (c cmdable) ClusterMyShardID(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "cluster", "myshardid")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterMyID(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "cluster", "myid")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterSlots(ctx context.Context) *ClusterSlotsCmd {
        cmd := NewClusterSlotsCmd(ctx, "cluster", "slots")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterShards(ctx context.Context) *ClusterShardsCmd {
        cmd := NewClusterShardsCmd(ctx, "cluster", "shards")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterLinks(ctx context.Context) *ClusterLinksCmd {
        cmd := NewClusterLinksCmd(ctx, "cluster", "links")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterNodes(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "cluster", "nodes")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterMeet(ctx context.Context, host, port string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "cluster", "meet", host, port)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterForget(ctx context.Context, nodeID string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "cluster", "forget", nodeID)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "cluster", "replicate", nodeID)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterResetSoft(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "cluster", "reset", "soft")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterResetHard(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "cluster", "reset", "hard")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterInfo(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "cluster", "info")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterKeySlot(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "cluster", "keyslot", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "cluster", "getkeysinslot", slot, count)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd {
        cmd := NewIntCmd(ctx, "cluster", "count-failure-reports", nodeID)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd {
        cmd := NewIntCmd(ctx, "cluster", "countkeysinslot", slot)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd {
        args := make([]interface{}, 2+len(slots))
        args[0] = "cluster"
        args[1] = "delslots"
        for i, slot := range slots {
                args[2+i] = slot
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd {
        size := max - min + 1
        slots := make([]int, size)
        for i := 0; i < size; i++ {
                slots[i] = min + i
        }
        return c.ClusterDelSlots(ctx, slots...)
}

func (c cmdable) ClusterSaveConfig(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "cluster", "saveconfig")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "cluster", "slaves", nodeID)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterFailover(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "cluster", "failover")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd {
        args := make([]interface{}, 2+len(slots))
        args[0] = "cluster"
        args[1] = "addslots"
        for i, num := range slots {
                args[2+i] = num
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd {
        size := max - min + 1
        slots := make([]int, size)
        for i := 0; i < size; i++ {
                slots[i] = min + i
        }
        return c.ClusterAddSlots(ctx, slots...)
}

func (c cmdable) ReadOnly(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "readonly")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ReadWrite(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "readwrite")
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "bufio"
        "context"
        "fmt"
        "net"
        "regexp"
        "strconv"
        "strings"
        "sync"
        "time"

        "github.com/redis/go-redis/v9/internal"
        "github.com/redis/go-redis/v9/internal/hscan"
        "github.com/redis/go-redis/v9/internal/proto"
        "github.com/redis/go-redis/v9/internal/util"
)

// keylessCommands contains Redis commands that have empty key specifications (9th slot empty)
// Only includes core Redis commands, excludes FT.*, ts.*, timeseries.*, search.* and subcommands
var keylessCommands = map[string]struct{}{
        "acl":          {},
        "asking":       {},
        "auth":         {},
        "bgrewriteaof": {},
        "bgsave":       {},
        "client":       {},
        "cluster":      {},
        "config":       {},
        "debug":        {},
        "discard":      {},
        "echo":         {},
        "exec":         {},
        "failover":     {},
        "function":     {},
        "hello":        {},
        "latency":      {},
        "lolwut":       {},
        "module":       {},
        "monitor":      {},
        "multi":        {},
        "pfselftest":   {},
        "ping":         {},
        "psubscribe":   {},
        "psync":        {},
        "publish":      {},
        "pubsub":       {},
        "punsubscribe": {},
        "quit":         {},
        "readonly":     {},
        "readwrite":    {},
        "replconf":     {},
        "replicaof":    {},
        "role":         {},
        "save":         {},
        "script":       {},
        "select":       {},
        "shutdown":     {},
        "slaveof":      {},
        "slowlog":      {},
        "subscribe":    {},
        "swapdb":       {},
        "sync":         {},
        "unsubscribe":  {},
        "unwatch":      {},
}

type Cmder interface {
        // command name.
        // e.g. "set k v ex 10" -> "set", "cluster info" -> "cluster".
        Name() string

        // full command name.
        // e.g. "set k v ex 10" -> "set", "cluster info" -> "cluster info".
        FullName() string

        // all args of the command.
        // e.g. "set k v ex 10" -> "[set k v ex 10]".
        Args() []interface{}

        // format request and response string.
        // e.g. "set k v ex 10" -> "set k v ex 10: OK", "get k" -> "get k: v".
        String() string

        stringArg(int) string
        firstKeyPos() int8
        SetFirstKeyPos(int8)

        readTimeout() *time.Duration
        readReply(rd *proto.Reader) error
        readRawReply(rd *proto.Reader) error
        SetErr(error)
        Err() error
}

func setCmdsErr(cmds []Cmder, e error) {
        for _, cmd := range cmds {
                if cmd.Err() == nil {
                        cmd.SetErr(e)
                }
        }
}

func cmdsFirstErr(cmds []Cmder) error {
        for _, cmd := range cmds {
                if err := cmd.Err(); err != nil {
                        return err
                }
        }
        return nil
}

func writeCmds(wr *proto.Writer, cmds []Cmder) error {
        for _, cmd := range cmds {
                if err := writeCmd(wr, cmd); err != nil {
                        return err
                }
        }
        return nil
}

func writeCmd(wr *proto.Writer, cmd Cmder) error {
        return wr.WriteArgs(cmd.Args())
}

// cmdFirstKeyPos returns the position of the first key in the command's arguments.
// If the command does not have a key, it returns 0.
// TODO: Use the data in CommandInfo to determine the first key position.
func cmdFirstKeyPos(cmd Cmder) int {
        if pos := cmd.firstKeyPos(); pos != 0 {
                return int(pos)
        }

        name := cmd.Name()

        // first check if the command is keyless
        if _, ok := keylessCommands[name]; ok {
                return 0
        }

        switch name {
        case "eval", "evalsha", "eval_ro", "evalsha_ro":
                if cmd.stringArg(2) != "0" {
                        return 3
                }

                return 0
        case "publish":
                return 1
        case "memory":
                // https://github.com/redis/redis/issues/7493
                if cmd.stringArg(1) == "usage" {
                        return 2
                }
        }
        return 1
}

func cmdString(cmd Cmder, val interface{}) string {
        b := make([]byte, 0, 64)

        for i, arg := range cmd.Args() {
                if i > 0 {
                        b = append(b, ' ')
                }
                b = internal.AppendArg(b, arg)
        }

        if err := cmd.Err(); err != nil {
                b = append(b, ": "...)
                b = append(b, err.Error()...)
        } else if val != nil {
                b = append(b, ": "...)
                b = internal.AppendArg(b, val)
        }

        return util.BytesToString(b)
}

//------------------------------------------------------------------------------

type baseCmd struct {
        ctx          context.Context
        args         []interface{}
        err          error
        keyPos       int8
        rawVal       interface{}
        _readTimeout *time.Duration
}

var _ Cmder = (*Cmd)(nil)

func (cmd *baseCmd) Name() string {
        if len(cmd.args) == 0 {
                return ""
        }
        // Cmd name must be lower cased.
        return internal.ToLower(cmd.stringArg(0))
}

func (cmd *baseCmd) FullName() string {
        switch name := cmd.Name(); name {
        case "cluster", "command":
                if len(cmd.args) == 1 {
                        return name
                }
                if s2, ok := cmd.args[1].(string); ok {
                        return name + " " + s2
                }
                return name
        default:
                return name
        }
}

func (cmd *baseCmd) Args() []interface{} {
        return cmd.args
}

func (cmd *baseCmd) stringArg(pos int) string {
        if pos < 0 || pos >= len(cmd.args) {
                return ""
        }
        arg := cmd.args[pos]
        switch v := arg.(type) {
        case string:
                return v
        case []byte:
                return string(v)
        default:
                // TODO: consider using appendArg
                return fmt.Sprint(v)
        }
}

func (cmd *baseCmd) firstKeyPos() int8 {
        return cmd.keyPos
}

func (cmd *baseCmd) SetFirstKeyPos(keyPos int8) {
        cmd.keyPos = keyPos
}

func (cmd *baseCmd) SetErr(e error) {
        cmd.err = e
}

func (cmd *baseCmd) Err() error {
        return cmd.err
}

func (cmd *baseCmd) readTimeout() *time.Duration {
        return cmd._readTimeout
}

func (cmd *baseCmd) setReadTimeout(d time.Duration) {
        cmd._readTimeout = &d
}

func (cmd *baseCmd) readRawReply(rd *proto.Reader) (err error) {
        cmd.rawVal, err = rd.ReadReply()
        return err
}

//------------------------------------------------------------------------------

type Cmd struct {
        baseCmd

        val interface{}
}

func NewCmd(ctx context.Context, args ...interface{}) *Cmd {
        return &Cmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *Cmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *Cmd) SetVal(val interface{}) {
        cmd.val = val
}

func (cmd *Cmd) Val() interface{} {
        return cmd.val
}

func (cmd *Cmd) Result() (interface{}, error) {
        return cmd.val, cmd.err
}

func (cmd *Cmd) Text() (string, error) {
        if cmd.err != nil {
                return "", cmd.err
        }
        return toString(cmd.val)
}

func toString(val interface{}) (string, error) {
        switch val := val.(type) {
        case string:
                return val, nil
        default:
                err := fmt.Errorf("redis: unexpected type=%T for String", val)
                return "", err
        }
}

func (cmd *Cmd) Int() (int, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        switch val := cmd.val.(type) {
        case int64:
                return int(val), nil
        case string:
                return strconv.Atoi(val)
        default:
                err := fmt.Errorf("redis: unexpected type=%T for Int", val)
                return 0, err
        }
}

func (cmd *Cmd) Int64() (int64, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        return toInt64(cmd.val)
}

func toInt64(val interface{}) (int64, error) {
        switch val := val.(type) {
        case int64:
                return val, nil
        case string:
                return strconv.ParseInt(val, 10, 64)
        default:
                err := fmt.Errorf("redis: unexpected type=%T for Int64", val)
                return 0, err
        }
}

func (cmd *Cmd) Uint64() (uint64, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        return toUint64(cmd.val)
}

func toUint64(val interface{}) (uint64, error) {
        switch val := val.(type) {
        case int64:
                return uint64(val), nil
        case string:
                return strconv.ParseUint(val, 10, 64)
        default:
                err := fmt.Errorf("redis: unexpected type=%T for Uint64", val)
                return 0, err
        }
}

func (cmd *Cmd) Float32() (float32, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        return toFloat32(cmd.val)
}

func toFloat32(val interface{}) (float32, error) {
        switch val := val.(type) {
        case int64:
                return float32(val), nil
        case string:
                f, err := strconv.ParseFloat(val, 32)
                if err != nil {
                        return 0, err
                }
                return float32(f), nil
        default:
                err := fmt.Errorf("redis: unexpected type=%T for Float32", val)
                return 0, err
        }
}

func (cmd *Cmd) Float64() (float64, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        return toFloat64(cmd.val)
}

func toFloat64(val interface{}) (float64, error) {
        switch val := val.(type) {
        case int64:
                return float64(val), nil
        case string:
                return strconv.ParseFloat(val, 64)
        default:
                err := fmt.Errorf("redis: unexpected type=%T for Float64", val)
                return 0, err
        }
}

func (cmd *Cmd) Bool() (bool, error) {
        if cmd.err != nil {
                return false, cmd.err
        }
        return toBool(cmd.val)
}

func toBool(val interface{}) (bool, error) {
        switch val := val.(type) {
        case bool:
                return val, nil
        case int64:
                return val != 0, nil
        case string:
                return strconv.ParseBool(val)
        default:
                err := fmt.Errorf("redis: unexpected type=%T for Bool", val)
                return false, err
        }
}

func (cmd *Cmd) Slice() ([]interface{}, error) {
        if cmd.err != nil {
                return nil, cmd.err
        }
        switch val := cmd.val.(type) {
        case []interface{}:
                return val, nil
        default:
                return nil, fmt.Errorf("redis: unexpected type=%T for Slice", val)
        }
}

func (cmd *Cmd) StringSlice() ([]string, error) {
        slice, err := cmd.Slice()
        if err != nil {
                return nil, err
        }

        ss := make([]string, len(slice))
        for i, iface := range slice {
                val, err := toString(iface)
                if err != nil {
                        return nil, err
                }
                ss[i] = val
        }
        return ss, nil
}

func (cmd *Cmd) Int64Slice() ([]int64, error) {
        slice, err := cmd.Slice()
        if err != nil {
                return nil, err
        }

        nums := make([]int64, len(slice))
        for i, iface := range slice {
                val, err := toInt64(iface)
                if err != nil {
                        return nil, err
                }
                nums[i] = val
        }
        return nums, nil
}

func (cmd *Cmd) Uint64Slice() ([]uint64, error) {
        slice, err := cmd.Slice()
        if err != nil {
                return nil, err
        }

        nums := make([]uint64, len(slice))
        for i, iface := range slice {
                val, err := toUint64(iface)
                if err != nil {
                        return nil, err
                }
                nums[i] = val
        }
        return nums, nil
}

func (cmd *Cmd) Float32Slice() ([]float32, error) {
        slice, err := cmd.Slice()
        if err != nil {
                return nil, err
        }

        floats := make([]float32, len(slice))
        for i, iface := range slice {
                val, err := toFloat32(iface)
                if err != nil {
                        return nil, err
                }
                floats[i] = val
        }
        return floats, nil
}

func (cmd *Cmd) Float64Slice() ([]float64, error) {
        slice, err := cmd.Slice()
        if err != nil {
                return nil, err
        }

        floats := make([]float64, len(slice))
        for i, iface := range slice {
                val, err := toFloat64(iface)
                if err != nil {
                        return nil, err
                }
                floats[i] = val
        }
        return floats, nil
}

func (cmd *Cmd) BoolSlice() ([]bool, error) {
        slice, err := cmd.Slice()
        if err != nil {
                return nil, err
        }

        bools := make([]bool, len(slice))
        for i, iface := range slice {
                val, err := toBool(iface)
                if err != nil {
                        return nil, err
                }
                bools[i] = val
        }
        return bools, nil
}

func (cmd *Cmd) readReply(rd *proto.Reader) (err error) {
        cmd.val, err = rd.ReadReply()
        return err
}

//------------------------------------------------------------------------------

type SliceCmd struct {
        baseCmd

        val []interface{}
}

var _ Cmder = (*SliceCmd)(nil)

func NewSliceCmd(ctx context.Context, args ...interface{}) *SliceCmd {
        return &SliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *SliceCmd) SetVal(val []interface{}) {
        cmd.val = val
}

func (cmd *SliceCmd) Val() []interface{} {
        return cmd.val
}

func (cmd *SliceCmd) Result() ([]interface{}, error) {
        return cmd.val, cmd.err
}

func (cmd *SliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

// Scan scans the results from the map into a destination struct. The map keys
// are matched in the Redis struct fields by the `redis:"field"` tag.
func (cmd *SliceCmd) Scan(dst interface{}) error {
        if cmd.err != nil {
                return cmd.err
        }

        // Pass the list of keys and values.
        // Skip the first two args for: HMGET key
        var args []interface{}
        if cmd.args[0] == "hmget" {
                args = cmd.args[2:]
        } else {
                // Otherwise, it's: MGET field field ...
                args = cmd.args[1:]
        }

        return hscan.Scan(dst, args, cmd.val)
}

func (cmd *SliceCmd) readReply(rd *proto.Reader) (err error) {
        cmd.val, err = rd.ReadSlice()
        return err
}

//------------------------------------------------------------------------------

type StatusCmd struct {
        baseCmd

        val string
}

var _ Cmder = (*StatusCmd)(nil)

func NewStatusCmd(ctx context.Context, args ...interface{}) *StatusCmd {
        return &StatusCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *StatusCmd) SetVal(val string) {
        cmd.val = val
}

func (cmd *StatusCmd) Val() string {
        return cmd.val
}

func (cmd *StatusCmd) Result() (string, error) {
        return cmd.val, cmd.err
}

func (cmd *StatusCmd) Bytes() ([]byte, error) {
        return util.StringToBytes(cmd.val), cmd.err
}

func (cmd *StatusCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *StatusCmd) readReply(rd *proto.Reader) (err error) {
        cmd.val, err = rd.ReadString()
        return err
}

//------------------------------------------------------------------------------

type IntCmd struct {
        baseCmd

        val int64
}

var _ Cmder = (*IntCmd)(nil)

func NewIntCmd(ctx context.Context, args ...interface{}) *IntCmd {
        return &IntCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *IntCmd) SetVal(val int64) {
        cmd.val = val
}

func (cmd *IntCmd) Val() int64 {
        return cmd.val
}

func (cmd *IntCmd) Result() (int64, error) {
        return cmd.val, cmd.err
}

func (cmd *IntCmd) Uint64() (uint64, error) {
        return uint64(cmd.val), cmd.err
}

func (cmd *IntCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *IntCmd) readReply(rd *proto.Reader) (err error) {
        cmd.val, err = rd.ReadInt()
        return err
}

//------------------------------------------------------------------------------

type IntSliceCmd struct {
        baseCmd

        val []int64
}

var _ Cmder = (*IntSliceCmd)(nil)

func NewIntSliceCmd(ctx context.Context, args ...interface{}) *IntSliceCmd {
        return &IntSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *IntSliceCmd) SetVal(val []int64) {
        cmd.val = val
}

func (cmd *IntSliceCmd) Val() []int64 {
        return cmd.val
}

func (cmd *IntSliceCmd) Result() ([]int64, error) {
        return cmd.val, cmd.err
}

func (cmd *IntSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *IntSliceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]int64, n)
        for i := 0; i < len(cmd.val); i++ {
                if cmd.val[i], err = rd.ReadInt(); err != nil {
                        return err
                }
        }
        return nil
}

//------------------------------------------------------------------------------

type DurationCmd struct {
        baseCmd

        val       time.Duration
        precision time.Duration
}

var _ Cmder = (*DurationCmd)(nil)

func NewDurationCmd(ctx context.Context, precision time.Duration, args ...interface{}) *DurationCmd {
        return &DurationCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
                precision: precision,
        }
}

func (cmd *DurationCmd) SetVal(val time.Duration) {
        cmd.val = val
}

func (cmd *DurationCmd) Val() time.Duration {
        return cmd.val
}

func (cmd *DurationCmd) Result() (time.Duration, error) {
        return cmd.val, cmd.err
}

func (cmd *DurationCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *DurationCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadInt()
        if err != nil {
                return err
        }
        switch n {
        // -2 if the key does not exist
        // -1 if the key exists but has no associated expire
        case -2, -1:
                cmd.val = time.Duration(n)
        default:
                cmd.val = time.Duration(n) * cmd.precision
        }
        return nil
}

//------------------------------------------------------------------------------

type TimeCmd struct {
        baseCmd

        val time.Time
}

var _ Cmder = (*TimeCmd)(nil)

func NewTimeCmd(ctx context.Context, args ...interface{}) *TimeCmd {
        return &TimeCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *TimeCmd) SetVal(val time.Time) {
        cmd.val = val
}

func (cmd *TimeCmd) Val() time.Time {
        return cmd.val
}

func (cmd *TimeCmd) Result() (time.Time, error) {
        return cmd.val, cmd.err
}

func (cmd *TimeCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *TimeCmd) readReply(rd *proto.Reader) error {
        if err := rd.ReadFixedArrayLen(2); err != nil {
                return err
        }
        second, err := rd.ReadInt()
        if err != nil {
                return err
        }
        microsecond, err := rd.ReadInt()
        if err != nil {
                return err
        }
        cmd.val = time.Unix(second, microsecond*1000)
        return nil
}

//------------------------------------------------------------------------------

type BoolCmd struct {
        baseCmd

        val bool
}

var _ Cmder = (*BoolCmd)(nil)

func NewBoolCmd(ctx context.Context, args ...interface{}) *BoolCmd {
        return &BoolCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *BoolCmd) SetVal(val bool) {
        cmd.val = val
}

func (cmd *BoolCmd) Val() bool {
        return cmd.val
}

func (cmd *BoolCmd) Result() (bool, error) {
        return cmd.val, cmd.err
}

func (cmd *BoolCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *BoolCmd) readReply(rd *proto.Reader) (err error) {
        cmd.val, err = rd.ReadBool()

        // `SET key value NX` returns nil when key already exists. But
        // `SETNX key value` returns bool (0/1). So convert nil to bool.
        if err == Nil {
                cmd.val = false
                err = nil
        }
        return err
}

//------------------------------------------------------------------------------

type StringCmd struct {
        baseCmd

        val string
}

var _ Cmder = (*StringCmd)(nil)

func NewStringCmd(ctx context.Context, args ...interface{}) *StringCmd {
        return &StringCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *StringCmd) SetVal(val string) {
        cmd.val = val
}

func (cmd *StringCmd) Val() string {
        return cmd.val
}

func (cmd *StringCmd) Result() (string, error) {
        return cmd.val, cmd.err
}

func (cmd *StringCmd) Bytes() ([]byte, error) {
        return util.StringToBytes(cmd.val), cmd.err
}

func (cmd *StringCmd) Bool() (bool, error) {
        if cmd.err != nil {
                return false, cmd.err
        }
        return strconv.ParseBool(cmd.val)
}

func (cmd *StringCmd) Int() (int, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        return strconv.Atoi(cmd.Val())
}

func (cmd *StringCmd) Int64() (int64, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        return strconv.ParseInt(cmd.Val(), 10, 64)
}

func (cmd *StringCmd) Uint64() (uint64, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        return strconv.ParseUint(cmd.Val(), 10, 64)
}

func (cmd *StringCmd) Float32() (float32, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        f, err := strconv.ParseFloat(cmd.Val(), 32)
        if err != nil {
                return 0, err
        }
        return float32(f), nil
}

func (cmd *StringCmd) Float64() (float64, error) {
        if cmd.err != nil {
                return 0, cmd.err
        }
        return strconv.ParseFloat(cmd.Val(), 64)
}

func (cmd *StringCmd) Time() (time.Time, error) {
        if cmd.err != nil {
                return time.Time{}, cmd.err
        }
        return time.Parse(time.RFC3339Nano, cmd.Val())
}

func (cmd *StringCmd) Scan(val interface{}) error {
        if cmd.err != nil {
                return cmd.err
        }
        return proto.Scan([]byte(cmd.val), val)
}

func (cmd *StringCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *StringCmd) readReply(rd *proto.Reader) (err error) {
        cmd.val, err = rd.ReadString()
        return err
}

//------------------------------------------------------------------------------

type FloatCmd struct {
        baseCmd

        val float64
}

var _ Cmder = (*FloatCmd)(nil)

func NewFloatCmd(ctx context.Context, args ...interface{}) *FloatCmd {
        return &FloatCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *FloatCmd) SetVal(val float64) {
        cmd.val = val
}

func (cmd *FloatCmd) Val() float64 {
        return cmd.val
}

func (cmd *FloatCmd) Result() (float64, error) {
        return cmd.val, cmd.err
}

func (cmd *FloatCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *FloatCmd) readReply(rd *proto.Reader) (err error) {
        cmd.val, err = rd.ReadFloat()
        return err
}

//------------------------------------------------------------------------------

type FloatSliceCmd struct {
        baseCmd

        val []float64
}

var _ Cmder = (*FloatSliceCmd)(nil)

func NewFloatSliceCmd(ctx context.Context, args ...interface{}) *FloatSliceCmd {
        return &FloatSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *FloatSliceCmd) SetVal(val []float64) {
        cmd.val = val
}

func (cmd *FloatSliceCmd) Val() []float64 {
        return cmd.val
}

func (cmd *FloatSliceCmd) Result() ([]float64, error) {
        return cmd.val, cmd.err
}

func (cmd *FloatSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *FloatSliceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        cmd.val = make([]float64, n)
        for i := 0; i < len(cmd.val); i++ {
                switch num, err := rd.ReadFloat(); {
                case err == Nil:
                        cmd.val[i] = 0
                case err != nil:
                        return err
                default:
                        cmd.val[i] = num
                }
        }
        return nil
}

//------------------------------------------------------------------------------

type StringSliceCmd struct {
        baseCmd

        val []string
}

var _ Cmder = (*StringSliceCmd)(nil)

func NewStringSliceCmd(ctx context.Context, args ...interface{}) *StringSliceCmd {
        return &StringSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *StringSliceCmd) SetVal(val []string) {
        cmd.val = val
}

func (cmd *StringSliceCmd) Val() []string {
        return cmd.val
}

func (cmd *StringSliceCmd) Result() ([]string, error) {
        return cmd.val, cmd.err
}

func (cmd *StringSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *StringSliceCmd) ScanSlice(container interface{}) error {
        return proto.ScanSlice(cmd.Val(), container)
}

func (cmd *StringSliceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]string, n)
        for i := 0; i < len(cmd.val); i++ {
                switch s, err := rd.ReadString(); {
                case err == Nil:
                        cmd.val[i] = ""
                case err != nil:
                        return err
                default:
                        cmd.val[i] = s
                }
        }
        return nil
}

//------------------------------------------------------------------------------

type KeyValue struct {
        Key   string
        Value string
}

type KeyValueSliceCmd struct {
        baseCmd

        val []KeyValue
}

var _ Cmder = (*KeyValueSliceCmd)(nil)

func NewKeyValueSliceCmd(ctx context.Context, args ...interface{}) *KeyValueSliceCmd {
        return &KeyValueSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *KeyValueSliceCmd) SetVal(val []KeyValue) {
        cmd.val = val
}

func (cmd *KeyValueSliceCmd) Val() []KeyValue {
        return cmd.val
}

func (cmd *KeyValueSliceCmd) Result() ([]KeyValue, error) {
        return cmd.val, cmd.err
}

func (cmd *KeyValueSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

// Many commands will respond to two formats:
//  1. 1) "one"
//  2. (double) 1
//  2. 1) "two"
//  2. (double) 2
//
// OR:
//  1. "two"
//  2. (double) 2
//  3. "one"
//  4. (double) 1
func (cmd *KeyValueSliceCmd) readReply(rd *proto.Reader) error { // nolint:dupl
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        // If the n is 0, can't continue reading.
        if n == 0 {
                cmd.val = make([]KeyValue, 0)
                return nil
        }

        typ, err := rd.PeekReplyType()
        if err != nil {
                return err
        }
        array := typ == proto.RespArray

        if array {
                cmd.val = make([]KeyValue, n)
        } else {
                cmd.val = make([]KeyValue, n/2)
        }

        for i := 0; i < len(cmd.val); i++ {
                if array {
                        if err = rd.ReadFixedArrayLen(2); err != nil {
                                return err
                        }
                }

                if cmd.val[i].Key, err = rd.ReadString(); err != nil {
                        return err
                }

                if cmd.val[i].Value, err = rd.ReadString(); err != nil {
                        return err
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type BoolSliceCmd struct {
        baseCmd

        val []bool
}

var _ Cmder = (*BoolSliceCmd)(nil)

func NewBoolSliceCmd(ctx context.Context, args ...interface{}) *BoolSliceCmd {
        return &BoolSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *BoolSliceCmd) SetVal(val []bool) {
        cmd.val = val
}

func (cmd *BoolSliceCmd) Val() []bool {
        return cmd.val
}

func (cmd *BoolSliceCmd) Result() ([]bool, error) {
        return cmd.val, cmd.err
}

func (cmd *BoolSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *BoolSliceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]bool, n)
        for i := 0; i < len(cmd.val); i++ {
                if cmd.val[i], err = rd.ReadBool(); err != nil {
                        return err
                }
        }
        return nil
}

//------------------------------------------------------------------------------

type MapStringStringCmd struct {
        baseCmd

        val map[string]string
}

var _ Cmder = (*MapStringStringCmd)(nil)

func NewMapStringStringCmd(ctx context.Context, args ...interface{}) *MapStringStringCmd {
        return &MapStringStringCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *MapStringStringCmd) Val() map[string]string {
        return cmd.val
}

func (cmd *MapStringStringCmd) SetVal(val map[string]string) {
        cmd.val = val
}

func (cmd *MapStringStringCmd) Result() (map[string]string, error) {
        return cmd.val, cmd.err
}

func (cmd *MapStringStringCmd) String() string {
        return cmdString(cmd, cmd.val)
}

// Scan scans the results from the map into a destination struct. The map keys
// are matched in the Redis struct fields by the `redis:"field"` tag.
func (cmd *MapStringStringCmd) Scan(dest interface{}) error {
        if cmd.err != nil {
                return cmd.err
        }

        strct, err := hscan.Struct(dest)
        if err != nil {
                return err
        }

        for k, v := range cmd.val {
                if err := strct.Scan(k, v); err != nil {
                        return err
                }
        }

        return nil
}

func (cmd *MapStringStringCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        cmd.val = make(map[string]string, n)
        for i := 0; i < n; i++ {
                key, err := rd.ReadString()
                if err != nil {
                        return err
                }

                value, err := rd.ReadString()
                if err != nil {
                        return err
                }

                cmd.val[key] = value
        }
        return nil
}

//------------------------------------------------------------------------------

type MapStringIntCmd struct {
        baseCmd

        val map[string]int64
}

var _ Cmder = (*MapStringIntCmd)(nil)

func NewMapStringIntCmd(ctx context.Context, args ...interface{}) *MapStringIntCmd {
        return &MapStringIntCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *MapStringIntCmd) SetVal(val map[string]int64) {
        cmd.val = val
}

func (cmd *MapStringIntCmd) Val() map[string]int64 {
        return cmd.val
}

func (cmd *MapStringIntCmd) Result() (map[string]int64, error) {
        return cmd.val, cmd.err
}

func (cmd *MapStringIntCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *MapStringIntCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        cmd.val = make(map[string]int64, n)
        for i := 0; i < n; i++ {
                key, err := rd.ReadString()
                if err != nil {
                        return err
                }

                nn, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                cmd.val[key] = nn
        }
        return nil
}

// ------------------------------------------------------------------------------
type MapStringSliceInterfaceCmd struct {
        baseCmd
        val map[string][]interface{}
}

func NewMapStringSliceInterfaceCmd(ctx context.Context, args ...interface{}) *MapStringSliceInterfaceCmd {
        return &MapStringSliceInterfaceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *MapStringSliceInterfaceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *MapStringSliceInterfaceCmd) SetVal(val map[string][]interface{}) {
        cmd.val = val
}

func (cmd *MapStringSliceInterfaceCmd) Result() (map[string][]interface{}, error) {
        return cmd.val, cmd.err
}

func (cmd *MapStringSliceInterfaceCmd) Val() map[string][]interface{} {
        return cmd.val
}

func (cmd *MapStringSliceInterfaceCmd) readReply(rd *proto.Reader) (err error) {
        readType, err := rd.PeekReplyType()
        if err != nil {
                return err
        }

        cmd.val = make(map[string][]interface{})

        switch readType {
        case proto.RespMap:
                n, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }
                for i := 0; i < n; i++ {
                        k, err := rd.ReadString()
                        if err != nil {
                                return err
                        }
                        nn, err := rd.ReadArrayLen()
                        if err != nil {
                                return err
                        }
                        cmd.val[k] = make([]interface{}, nn)
                        for j := 0; j < nn; j++ {
                                value, err := rd.ReadReply()
                                if err != nil {
                                        return err
                                }
                                cmd.val[k][j] = value
                        }
                }
        case proto.RespArray:
                // RESP2 response
                n, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }

                for i := 0; i < n; i++ {
                        // Each entry in this array is itself an array with key details
                        itemLen, err := rd.ReadArrayLen()
                        if err != nil {
                                return err
                        }

                        key, err := rd.ReadString()
                        if err != nil {
                                return err
                        }
                        cmd.val[key] = make([]interface{}, 0, itemLen-1)
                        for j := 1; j < itemLen; j++ {
                                // Read the inner array for timestamp-value pairs
                                data, err := rd.ReadReply()
                                if err != nil {
                                        return err
                                }
                                cmd.val[key] = append(cmd.val[key], data)
                        }
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type StringStructMapCmd struct {
        baseCmd

        val map[string]struct{}
}

var _ Cmder = (*StringStructMapCmd)(nil)

func NewStringStructMapCmd(ctx context.Context, args ...interface{}) *StringStructMapCmd {
        return &StringStructMapCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *StringStructMapCmd) SetVal(val map[string]struct{}) {
        cmd.val = val
}

func (cmd *StringStructMapCmd) Val() map[string]struct{} {
        return cmd.val
}

func (cmd *StringStructMapCmd) Result() (map[string]struct{}, error) {
        return cmd.val, cmd.err
}

func (cmd *StringStructMapCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *StringStructMapCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        cmd.val = make(map[string]struct{}, n)
        for i := 0; i < n; i++ {
                key, err := rd.ReadString()
                if err != nil {
                        return err
                }
                cmd.val[key] = struct{}{}
        }
        return nil
}

//------------------------------------------------------------------------------

type XMessage struct {
        ID     string
        Values map[string]interface{}
}

type XMessageSliceCmd struct {
        baseCmd

        val []XMessage
}

var _ Cmder = (*XMessageSliceCmd)(nil)

func NewXMessageSliceCmd(ctx context.Context, args ...interface{}) *XMessageSliceCmd {
        return &XMessageSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *XMessageSliceCmd) SetVal(val []XMessage) {
        cmd.val = val
}

func (cmd *XMessageSliceCmd) Val() []XMessage {
        return cmd.val
}

func (cmd *XMessageSliceCmd) Result() ([]XMessage, error) {
        return cmd.val, cmd.err
}

func (cmd *XMessageSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XMessageSliceCmd) readReply(rd *proto.Reader) (err error) {
        cmd.val, err = readXMessageSlice(rd)
        return err
}

func readXMessageSlice(rd *proto.Reader) ([]XMessage, error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return nil, err
        }

        msgs := make([]XMessage, n)
        for i := 0; i < len(msgs); i++ {
                if msgs[i], err = readXMessage(rd); err != nil {
                        return nil, err
                }
        }
        return msgs, nil
}

func readXMessage(rd *proto.Reader) (XMessage, error) {
        if err := rd.ReadFixedArrayLen(2); err != nil {
                return XMessage{}, err
        }

        id, err := rd.ReadString()
        if err != nil {
                return XMessage{}, err
        }

        v, err := stringInterfaceMapParser(rd)
        if err != nil {
                if err != proto.Nil {
                        return XMessage{}, err
                }
        }

        return XMessage{
                ID:     id,
                Values: v,
        }, nil
}

func stringInterfaceMapParser(rd *proto.Reader) (map[string]interface{}, error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return nil, err
        }

        m := make(map[string]interface{}, n)
        for i := 0; i < n; i++ {
                key, err := rd.ReadString()
                if err != nil {
                        return nil, err
                }

                value, err := rd.ReadString()
                if err != nil {
                        return nil, err
                }

                m[key] = value
        }
        return m, nil
}

//------------------------------------------------------------------------------

type XStream struct {
        Stream   string
        Messages []XMessage
}

type XStreamSliceCmd struct {
        baseCmd

        val []XStream
}

var _ Cmder = (*XStreamSliceCmd)(nil)

func NewXStreamSliceCmd(ctx context.Context, args ...interface{}) *XStreamSliceCmd {
        return &XStreamSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *XStreamSliceCmd) SetVal(val []XStream) {
        cmd.val = val
}

func (cmd *XStreamSliceCmd) Val() []XStream {
        return cmd.val
}

func (cmd *XStreamSliceCmd) Result() ([]XStream, error) {
        return cmd.val, cmd.err
}

func (cmd *XStreamSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XStreamSliceCmd) readReply(rd *proto.Reader) error {
        typ, err := rd.PeekReplyType()
        if err != nil {
                return err
        }

        var n int
        if typ == proto.RespMap {
                n, err = rd.ReadMapLen()
        } else {
                n, err = rd.ReadArrayLen()
        }
        if err != nil {
                return err
        }
        cmd.val = make([]XStream, n)
        for i := 0; i < len(cmd.val); i++ {
                if typ != proto.RespMap {
                        if err = rd.ReadFixedArrayLen(2); err != nil {
                                return err
                        }
                }
                if cmd.val[i].Stream, err = rd.ReadString(); err != nil {
                        return err
                }
                if cmd.val[i].Messages, err = readXMessageSlice(rd); err != nil {
                        return err
                }
        }
        return nil
}

//------------------------------------------------------------------------------

type XPending struct {
        Count     int64
        Lower     string
        Higher    string
        Consumers map[string]int64
}

type XPendingCmd struct {
        baseCmd
        val *XPending
}

var _ Cmder = (*XPendingCmd)(nil)

func NewXPendingCmd(ctx context.Context, args ...interface{}) *XPendingCmd {
        return &XPendingCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *XPendingCmd) SetVal(val *XPending) {
        cmd.val = val
}

func (cmd *XPendingCmd) Val() *XPending {
        return cmd.val
}

func (cmd *XPendingCmd) Result() (*XPending, error) {
        return cmd.val, cmd.err
}

func (cmd *XPendingCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XPendingCmd) readReply(rd *proto.Reader) error {
        var err error
        if err = rd.ReadFixedArrayLen(4); err != nil {
                return err
        }
        cmd.val = &XPending{}

        if cmd.val.Count, err = rd.ReadInt(); err != nil {
                return err
        }

        if cmd.val.Lower, err = rd.ReadString(); err != nil && err != Nil {
                return err
        }

        if cmd.val.Higher, err = rd.ReadString(); err != nil && err != Nil {
                return err
        }

        n, err := rd.ReadArrayLen()
        if err != nil && err != Nil {
                return err
        }
        cmd.val.Consumers = make(map[string]int64, n)
        for i := 0; i < n; i++ {
                if err = rd.ReadFixedArrayLen(2); err != nil {
                        return err
                }

                consumerName, err := rd.ReadString()
                if err != nil {
                        return err
                }
                consumerPending, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                cmd.val.Consumers[consumerName] = consumerPending
        }
        return nil
}

//------------------------------------------------------------------------------

type XPendingExt struct {
        ID         string
        Consumer   string
        Idle       time.Duration
        RetryCount int64
}

type XPendingExtCmd struct {
        baseCmd
        val []XPendingExt
}

var _ Cmder = (*XPendingExtCmd)(nil)

func NewXPendingExtCmd(ctx context.Context, args ...interface{}) *XPendingExtCmd {
        return &XPendingExtCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *XPendingExtCmd) SetVal(val []XPendingExt) {
        cmd.val = val
}

func (cmd *XPendingExtCmd) Val() []XPendingExt {
        return cmd.val
}

func (cmd *XPendingExtCmd) Result() ([]XPendingExt, error) {
        return cmd.val, cmd.err
}

func (cmd *XPendingExtCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XPendingExtCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]XPendingExt, n)

        for i := 0; i < len(cmd.val); i++ {
                if err = rd.ReadFixedArrayLen(4); err != nil {
                        return err
                }

                if cmd.val[i].ID, err = rd.ReadString(); err != nil {
                        return err
                }

                if cmd.val[i].Consumer, err = rd.ReadString(); err != nil && err != Nil {
                        return err
                }

                idle, err := rd.ReadInt()
                if err != nil && err != Nil {
                        return err
                }
                cmd.val[i].Idle = time.Duration(idle) * time.Millisecond

                if cmd.val[i].RetryCount, err = rd.ReadInt(); err != nil && err != Nil {
                        return err
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type XAutoClaimCmd struct {
        baseCmd

        start string
        val   []XMessage
}

var _ Cmder = (*XAutoClaimCmd)(nil)

func NewXAutoClaimCmd(ctx context.Context, args ...interface{}) *XAutoClaimCmd {
        return &XAutoClaimCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *XAutoClaimCmd) SetVal(val []XMessage, start string) {
        cmd.val = val
        cmd.start = start
}

func (cmd *XAutoClaimCmd) Val() (messages []XMessage, start string) {
        return cmd.val, cmd.start
}

func (cmd *XAutoClaimCmd) Result() (messages []XMessage, start string, err error) {
        return cmd.val, cmd.start, cmd.err
}

func (cmd *XAutoClaimCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XAutoClaimCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        switch n {
        case 2, // Redis 6
                3: // Redis 7:
                // ok
        default:
                return fmt.Errorf("redis: got %d elements in XAutoClaim reply, wanted 2/3", n)
        }

        cmd.start, err = rd.ReadString()
        if err != nil {
                return err
        }

        cmd.val, err = readXMessageSlice(rd)
        if err != nil {
                return err
        }

        if n >= 3 {
                if err := rd.DiscardNext(); err != nil {
                        return err
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type XAutoClaimJustIDCmd struct {
        baseCmd

        start string
        val   []string
}

var _ Cmder = (*XAutoClaimJustIDCmd)(nil)

func NewXAutoClaimJustIDCmd(ctx context.Context, args ...interface{}) *XAutoClaimJustIDCmd {
        return &XAutoClaimJustIDCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *XAutoClaimJustIDCmd) SetVal(val []string, start string) {
        cmd.val = val
        cmd.start = start
}

func (cmd *XAutoClaimJustIDCmd) Val() (ids []string, start string) {
        return cmd.val, cmd.start
}

func (cmd *XAutoClaimJustIDCmd) Result() (ids []string, start string, err error) {
        return cmd.val, cmd.start, cmd.err
}

func (cmd *XAutoClaimJustIDCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XAutoClaimJustIDCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        switch n {
        case 2, // Redis 6
                3: // Redis 7:
                // ok
        default:
                return fmt.Errorf("redis: got %d elements in XAutoClaimJustID reply, wanted 2/3", n)
        }

        cmd.start, err = rd.ReadString()
        if err != nil {
                return err
        }

        nn, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        cmd.val = make([]string, nn)
        for i := 0; i < nn; i++ {
                cmd.val[i], err = rd.ReadString()
                if err != nil {
                        return err
                }
        }

        if n >= 3 {
                if err := rd.DiscardNext(); err != nil {
                        return err
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type XInfoConsumersCmd struct {
        baseCmd
        val []XInfoConsumer
}

type XInfoConsumer struct {
        Name     string
        Pending  int64
        Idle     time.Duration
        Inactive time.Duration
}

var _ Cmder = (*XInfoConsumersCmd)(nil)

func NewXInfoConsumersCmd(ctx context.Context, stream string, group string) *XInfoConsumersCmd {
        return &XInfoConsumersCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: []interface{}{"xinfo", "consumers", stream, group},
                },
        }
}

func (cmd *XInfoConsumersCmd) SetVal(val []XInfoConsumer) {
        cmd.val = val
}

func (cmd *XInfoConsumersCmd) Val() []XInfoConsumer {
        return cmd.val
}

func (cmd *XInfoConsumersCmd) Result() ([]XInfoConsumer, error) {
        return cmd.val, cmd.err
}

func (cmd *XInfoConsumersCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XInfoConsumersCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]XInfoConsumer, n)

        for i := 0; i < len(cmd.val); i++ {
                nn, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }

                var key string
                for f := 0; f < nn; f++ {
                        key, err = rd.ReadString()
                        if err != nil {
                                return err
                        }

                        switch key {
                        case "name":
                                cmd.val[i].Name, err = rd.ReadString()
                        case "pending":
                                cmd.val[i].Pending, err = rd.ReadInt()
                        case "idle":
                                var idle int64
                                idle, err = rd.ReadInt()
                                cmd.val[i].Idle = time.Duration(idle) * time.Millisecond
                        case "inactive":
                                var inactive int64
                                inactive, err = rd.ReadInt()
                                cmd.val[i].Inactive = time.Duration(inactive) * time.Millisecond
                        default:
                                return fmt.Errorf("redis: unexpected content %s in XINFO CONSUMERS reply", key)
                        }
                        if err != nil {
                                return err
                        }
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type XInfoGroupsCmd struct {
        baseCmd
        val []XInfoGroup
}

type XInfoGroup struct {
        Name            string
        Consumers       int64
        Pending         int64
        LastDeliveredID string
        EntriesRead     int64
        // Lag represents the number of pending messages in the stream not yet
        // delivered to this consumer group. Returns -1 when the lag cannot be determined.
        Lag int64
}

var _ Cmder = (*XInfoGroupsCmd)(nil)

func NewXInfoGroupsCmd(ctx context.Context, stream string) *XInfoGroupsCmd {
        return &XInfoGroupsCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: []interface{}{"xinfo", "groups", stream},
                },
        }
}

func (cmd *XInfoGroupsCmd) SetVal(val []XInfoGroup) {
        cmd.val = val
}

func (cmd *XInfoGroupsCmd) Val() []XInfoGroup {
        return cmd.val
}

func (cmd *XInfoGroupsCmd) Result() ([]XInfoGroup, error) {
        return cmd.val, cmd.err
}

func (cmd *XInfoGroupsCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XInfoGroupsCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]XInfoGroup, n)

        for i := 0; i < len(cmd.val); i++ {
                group := &cmd.val[i]

                nn, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }

                var key string
                for j := 0; j < nn; j++ {
                        key, err = rd.ReadString()
                        if err != nil {
                                return err
                        }

                        switch key {
                        case "name":
                                group.Name, err = rd.ReadString()
                                if err != nil {
                                        return err
                                }
                        case "consumers":
                                group.Consumers, err = rd.ReadInt()
                                if err != nil {
                                        return err
                                }
                        case "pending":
                                group.Pending, err = rd.ReadInt()
                                if err != nil {
                                        return err
                                }
                        case "last-delivered-id":
                                group.LastDeliveredID, err = rd.ReadString()
                                if err != nil {
                                        return err
                                }
                        case "entries-read":
                                group.EntriesRead, err = rd.ReadInt()
                                if err != nil && err != Nil {
                                        return err
                                }
                        case "lag":
                                group.Lag, err = rd.ReadInt()

                                // lag: the number of entries in the stream that are still waiting to be delivered
                                // to the group's consumers, or a NULL(Nil) when that number can't be determined.
                                // In that case, we return -1.
                                if err != nil && err != Nil {
                                        return err
                                } else if err == Nil {
                                        group.Lag = -1
                                }
                        default:
                                return fmt.Errorf("redis: unexpected key %q in XINFO GROUPS reply", key)
                        }
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type XInfoStreamCmd struct {
        baseCmd
        val *XInfoStream
}

type XInfoStream struct {
        Length               int64
        RadixTreeKeys        int64
        RadixTreeNodes       int64
        Groups               int64
        LastGeneratedID      string
        MaxDeletedEntryID    string
        EntriesAdded         int64
        FirstEntry           XMessage
        LastEntry            XMessage
        RecordedFirstEntryID string
}

var _ Cmder = (*XInfoStreamCmd)(nil)

func NewXInfoStreamCmd(ctx context.Context, stream string) *XInfoStreamCmd {
        return &XInfoStreamCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: []interface{}{"xinfo", "stream", stream},
                },
        }
}

func (cmd *XInfoStreamCmd) SetVal(val *XInfoStream) {
        cmd.val = val
}

func (cmd *XInfoStreamCmd) Val() *XInfoStream {
        return cmd.val
}

func (cmd *XInfoStreamCmd) Result() (*XInfoStream, error) {
        return cmd.val, cmd.err
}

func (cmd *XInfoStreamCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XInfoStreamCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }
        cmd.val = &XInfoStream{}

        for i := 0; i < n; i++ {
                key, err := rd.ReadString()
                if err != nil {
                        return err
                }
                switch key {
                case "length":
                        cmd.val.Length, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "radix-tree-keys":
                        cmd.val.RadixTreeKeys, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "radix-tree-nodes":
                        cmd.val.RadixTreeNodes, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "groups":
                        cmd.val.Groups, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "last-generated-id":
                        cmd.val.LastGeneratedID, err = rd.ReadString()
                        if err != nil {
                                return err
                        }
                case "max-deleted-entry-id":
                        cmd.val.MaxDeletedEntryID, err = rd.ReadString()
                        if err != nil {
                                return err
                        }
                case "entries-added":
                        cmd.val.EntriesAdded, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "first-entry":
                        cmd.val.FirstEntry, err = readXMessage(rd)
                        if err != nil && err != Nil {
                                return err
                        }
                case "last-entry":
                        cmd.val.LastEntry, err = readXMessage(rd)
                        if err != nil && err != Nil {
                                return err
                        }
                case "recorded-first-entry-id":
                        cmd.val.RecordedFirstEntryID, err = rd.ReadString()
                        if err != nil {
                                return err
                        }
                default:
                        return fmt.Errorf("redis: unexpected key %q in XINFO STREAM reply", key)
                }
        }
        return nil
}

//------------------------------------------------------------------------------

type XInfoStreamFullCmd struct {
        baseCmd
        val *XInfoStreamFull
}

type XInfoStreamFull struct {
        Length               int64
        RadixTreeKeys        int64
        RadixTreeNodes       int64
        LastGeneratedID      string
        MaxDeletedEntryID    string
        EntriesAdded         int64
        Entries              []XMessage
        Groups               []XInfoStreamGroup
        RecordedFirstEntryID string
}

type XInfoStreamGroup struct {
        Name            string
        LastDeliveredID string
        EntriesRead     int64
        Lag             int64
        PelCount        int64
        Pending         []XInfoStreamGroupPending
        Consumers       []XInfoStreamConsumer
}

type XInfoStreamGroupPending struct {
        ID            string
        Consumer      string
        DeliveryTime  time.Time
        DeliveryCount int64
}

type XInfoStreamConsumer struct {
        Name       string
        SeenTime   time.Time
        ActiveTime time.Time
        PelCount   int64
        Pending    []XInfoStreamConsumerPending
}

type XInfoStreamConsumerPending struct {
        ID            string
        DeliveryTime  time.Time
        DeliveryCount int64
}

var _ Cmder = (*XInfoStreamFullCmd)(nil)

func NewXInfoStreamFullCmd(ctx context.Context, args ...interface{}) *XInfoStreamFullCmd {
        return &XInfoStreamFullCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *XInfoStreamFullCmd) SetVal(val *XInfoStreamFull) {
        cmd.val = val
}

func (cmd *XInfoStreamFullCmd) Val() *XInfoStreamFull {
        return cmd.val
}

func (cmd *XInfoStreamFullCmd) Result() (*XInfoStreamFull, error) {
        return cmd.val, cmd.err
}

func (cmd *XInfoStreamFullCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *XInfoStreamFullCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        cmd.val = &XInfoStreamFull{}

        for i := 0; i < n; i++ {
                key, err := rd.ReadString()
                if err != nil {
                        return err
                }

                switch key {
                case "length":
                        cmd.val.Length, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "radix-tree-keys":
                        cmd.val.RadixTreeKeys, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "radix-tree-nodes":
                        cmd.val.RadixTreeNodes, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "last-generated-id":
                        cmd.val.LastGeneratedID, err = rd.ReadString()
                        if err != nil {
                                return err
                        }
                case "entries-added":
                        cmd.val.EntriesAdded, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                case "entries":
                        cmd.val.Entries, err = readXMessageSlice(rd)
                        if err != nil {
                                return err
                        }
                case "groups":
                        cmd.val.Groups, err = readStreamGroups(rd)
                        if err != nil {
                                return err
                        }
                case "max-deleted-entry-id":
                        cmd.val.MaxDeletedEntryID, err = rd.ReadString()
                        if err != nil {
                                return err
                        }
                case "recorded-first-entry-id":
                        cmd.val.RecordedFirstEntryID, err = rd.ReadString()
                        if err != nil {
                                return err
                        }
                default:
                        return fmt.Errorf("redis: unexpected key %q in XINFO STREAM FULL reply", key)
                }
        }
        return nil
}

func readStreamGroups(rd *proto.Reader) ([]XInfoStreamGroup, error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return nil, err
        }
        groups := make([]XInfoStreamGroup, 0, n)
        for i := 0; i < n; i++ {
                nn, err := rd.ReadMapLen()
                if err != nil {
                        return nil, err
                }

                group := XInfoStreamGroup{}

                for j := 0; j < nn; j++ {
                        key, err := rd.ReadString()
                        if err != nil {
                                return nil, err
                        }

                        switch key {
                        case "name":
                                group.Name, err = rd.ReadString()
                                if err != nil {
                                        return nil, err
                                }
                        case "last-delivered-id":
                                group.LastDeliveredID, err = rd.ReadString()
                                if err != nil {
                                        return nil, err
                                }
                        case "entries-read":
                                group.EntriesRead, err = rd.ReadInt()
                                if err != nil && err != Nil {
                                        return nil, err
                                }
                        case "lag":
                                // lag: the number of entries in the stream that are still waiting to be delivered
                                // to the group's consumers, or a NULL(Nil) when that number can't be determined.
                                group.Lag, err = rd.ReadInt()
                                if err != nil && err != Nil {
                                        return nil, err
                                }
                        case "pel-count":
                                group.PelCount, err = rd.ReadInt()
                                if err != nil {
                                        return nil, err
                                }
                        case "pending":
                                group.Pending, err = readXInfoStreamGroupPending(rd)
                                if err != nil {
                                        return nil, err
                                }
                        case "consumers":
                                group.Consumers, err = readXInfoStreamConsumers(rd)
                                if err != nil {
                                        return nil, err
                                }
                        default:
                                return nil, fmt.Errorf("redis: unexpected key %q in XINFO STREAM FULL reply", key)
                        }
                }

                groups = append(groups, group)
        }

        return groups, nil
}

func readXInfoStreamGroupPending(rd *proto.Reader) ([]XInfoStreamGroupPending, error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return nil, err
        }

        pending := make([]XInfoStreamGroupPending, 0, n)

        for i := 0; i < n; i++ {
                if err = rd.ReadFixedArrayLen(4); err != nil {
                        return nil, err
                }

                p := XInfoStreamGroupPending{}

                p.ID, err = rd.ReadString()
                if err != nil {
                        return nil, err
                }

                p.Consumer, err = rd.ReadString()
                if err != nil {
                        return nil, err
                }

                delivery, err := rd.ReadInt()
                if err != nil {
                        return nil, err
                }
                p.DeliveryTime = time.Unix(delivery/1000, delivery%1000*int64(time.Millisecond))

                p.DeliveryCount, err = rd.ReadInt()
                if err != nil {
                        return nil, err
                }

                pending = append(pending, p)
        }

        return pending, nil
}

func readXInfoStreamConsumers(rd *proto.Reader) ([]XInfoStreamConsumer, error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return nil, err
        }

        consumers := make([]XInfoStreamConsumer, 0, n)

        for i := 0; i < n; i++ {
                nn, err := rd.ReadMapLen()
                if err != nil {
                        return nil, err
                }

                c := XInfoStreamConsumer{}

                for f := 0; f < nn; f++ {
                        cKey, err := rd.ReadString()
                        if err != nil {
                                return nil, err
                        }

                        switch cKey {
                        case "name":
                                c.Name, err = rd.ReadString()
                        case "seen-time":
                                seen, err := rd.ReadInt()
                                if err != nil {
                                        return nil, err
                                }
                                c.SeenTime = time.UnixMilli(seen)
                        case "active-time":
                                active, err := rd.ReadInt()
                                if err != nil {
                                        return nil, err
                                }
                                c.ActiveTime = time.UnixMilli(active)
                        case "pel-count":
                                c.PelCount, err = rd.ReadInt()
                        case "pending":
                                pendingNumber, err := rd.ReadArrayLen()
                                if err != nil {
                                        return nil, err
                                }

                                c.Pending = make([]XInfoStreamConsumerPending, 0, pendingNumber)

                                for pn := 0; pn < pendingNumber; pn++ {
                                        if err = rd.ReadFixedArrayLen(3); err != nil {
                                                return nil, err
                                        }

                                        p := XInfoStreamConsumerPending{}

                                        p.ID, err = rd.ReadString()
                                        if err != nil {
                                                return nil, err
                                        }

                                        delivery, err := rd.ReadInt()
                                        if err != nil {
                                                return nil, err
                                        }
                                        p.DeliveryTime = time.Unix(delivery/1000, delivery%1000*int64(time.Millisecond))

                                        p.DeliveryCount, err = rd.ReadInt()
                                        if err != nil {
                                                return nil, err
                                        }

                                        c.Pending = append(c.Pending, p)
                                }
                        default:
                                return nil, fmt.Errorf("redis: unexpected content %s "+
                                        "in XINFO STREAM FULL reply", cKey)
                        }
                        if err != nil {
                                return nil, err
                        }
                }
                consumers = append(consumers, c)
        }

        return consumers, nil
}

//------------------------------------------------------------------------------

type ZSliceCmd struct {
        baseCmd

        val []Z
}

var _ Cmder = (*ZSliceCmd)(nil)

func NewZSliceCmd(ctx context.Context, args ...interface{}) *ZSliceCmd {
        return &ZSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ZSliceCmd) SetVal(val []Z) {
        cmd.val = val
}

func (cmd *ZSliceCmd) Val() []Z {
        return cmd.val
}

func (cmd *ZSliceCmd) Result() ([]Z, error) {
        return cmd.val, cmd.err
}

func (cmd *ZSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ZSliceCmd) readReply(rd *proto.Reader) error { // nolint:dupl
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        // If the n is 0, can't continue reading.
        if n == 0 {
                cmd.val = make([]Z, 0)
                return nil
        }

        typ, err := rd.PeekReplyType()
        if err != nil {
                return err
        }
        array := typ == proto.RespArray

        if array {
                cmd.val = make([]Z, n)
        } else {
                cmd.val = make([]Z, n/2)
        }

        for i := 0; i < len(cmd.val); i++ {
                if array {
                        if err = rd.ReadFixedArrayLen(2); err != nil {
                                return err
                        }
                }

                if cmd.val[i].Member, err = rd.ReadString(); err != nil {
                        return err
                }

                if cmd.val[i].Score, err = rd.ReadFloat(); err != nil {
                        return err
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type ZWithKeyCmd struct {
        baseCmd

        val *ZWithKey
}

var _ Cmder = (*ZWithKeyCmd)(nil)

func NewZWithKeyCmd(ctx context.Context, args ...interface{}) *ZWithKeyCmd {
        return &ZWithKeyCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ZWithKeyCmd) SetVal(val *ZWithKey) {
        cmd.val = val
}

func (cmd *ZWithKeyCmd) Val() *ZWithKey {
        return cmd.val
}

func (cmd *ZWithKeyCmd) Result() (*ZWithKey, error) {
        return cmd.val, cmd.err
}

func (cmd *ZWithKeyCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ZWithKeyCmd) readReply(rd *proto.Reader) (err error) {
        if err = rd.ReadFixedArrayLen(3); err != nil {
                return err
        }
        cmd.val = &ZWithKey{}

        if cmd.val.Key, err = rd.ReadString(); err != nil {
                return err
        }
        if cmd.val.Member, err = rd.ReadString(); err != nil {
                return err
        }
        if cmd.val.Score, err = rd.ReadFloat(); err != nil {
                return err
        }

        return nil
}

//------------------------------------------------------------------------------

type ScanCmd struct {
        baseCmd

        page   []string
        cursor uint64

        process cmdable
}

var _ Cmder = (*ScanCmd)(nil)

func NewScanCmd(ctx context.Context, process cmdable, args ...interface{}) *ScanCmd {
        return &ScanCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
                process: process,
        }
}

func (cmd *ScanCmd) SetVal(page []string, cursor uint64) {
        cmd.page = page
        cmd.cursor = cursor
}

func (cmd *ScanCmd) Val() (keys []string, cursor uint64) {
        return cmd.page, cmd.cursor
}

func (cmd *ScanCmd) Result() (keys []string, cursor uint64, err error) {
        return cmd.page, cmd.cursor, cmd.err
}

func (cmd *ScanCmd) String() string {
        return cmdString(cmd, cmd.page)
}

func (cmd *ScanCmd) readReply(rd *proto.Reader) error {
        if err := rd.ReadFixedArrayLen(2); err != nil {
                return err
        }

        cursor, err := rd.ReadUint()
        if err != nil {
                return err
        }
        cmd.cursor = cursor

        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.page = make([]string, n)

        for i := 0; i < len(cmd.page); i++ {
                if cmd.page[i], err = rd.ReadString(); err != nil {
                        return err
                }
        }
        return nil
}

// Iterator creates a new ScanIterator.
func (cmd *ScanCmd) Iterator() *ScanIterator {
        return &ScanIterator{
                cmd: cmd,
        }
}

//------------------------------------------------------------------------------

type ClusterNode struct {
        ID                 string
        Addr               string
        NetworkingMetadata map[string]string
}

type ClusterSlot struct {
        Start int
        End   int
        Nodes []ClusterNode
}

type ClusterSlotsCmd struct {
        baseCmd

        val []ClusterSlot
}

var _ Cmder = (*ClusterSlotsCmd)(nil)

func NewClusterSlotsCmd(ctx context.Context, args ...interface{}) *ClusterSlotsCmd {
        return &ClusterSlotsCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ClusterSlotsCmd) SetVal(val []ClusterSlot) {
        cmd.val = val
}

func (cmd *ClusterSlotsCmd) Val() []ClusterSlot {
        return cmd.val
}

func (cmd *ClusterSlotsCmd) Result() ([]ClusterSlot, error) {
        return cmd.val, cmd.err
}

func (cmd *ClusterSlotsCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ClusterSlotsCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]ClusterSlot, n)

        for i := 0; i < len(cmd.val); i++ {
                n, err = rd.ReadArrayLen()
                if err != nil {
                        return err
                }
                if n < 2 {
                        return fmt.Errorf("redis: got %d elements in cluster info, expected at least 2", n)
                }

                start, err := rd.ReadInt()
                if err != nil {
                        return err
                }

                end, err := rd.ReadInt()
                if err != nil {
                        return err
                }

                // subtract start and end.
                nodes := make([]ClusterNode, n-2)

                for j := 0; j < len(nodes); j++ {
                        nn, err := rd.ReadArrayLen()
                        if err != nil {
                                return err
                        }
                        if nn < 2 || nn > 4 {
                                return fmt.Errorf("got %d elements in cluster info address, expected 2, 3, or 4", n)
                        }

                        ip, err := rd.ReadString()
                        if err != nil {
                                return err
                        }

                        port, err := rd.ReadString()
                        if err != nil {
                                return err
                        }

                        nodes[j].Addr = net.JoinHostPort(ip, port)

                        if nn >= 3 {
                                id, err := rd.ReadString()
                                if err != nil {
                                        return err
                                }
                                nodes[j].ID = id
                        }

                        if nn >= 4 {
                                metadataLength, err := rd.ReadMapLen()
                                if err != nil {
                                        return err
                                }

                                networkingMetadata := make(map[string]string, metadataLength)

                                for i := 0; i < metadataLength; i++ {
                                        key, err := rd.ReadString()
                                        if err != nil {
                                                return err
                                        }
                                        value, err := rd.ReadString()
                                        if err != nil {
                                                return err
                                        }
                                        networkingMetadata[key] = value
                                }

                                nodes[j].NetworkingMetadata = networkingMetadata
                        }
                }

                cmd.val[i] = ClusterSlot{
                        Start: int(start),
                        End:   int(end),
                        Nodes: nodes,
                }
        }

        return nil
}

//------------------------------------------------------------------------------

// GeoLocation is used with GeoAdd to add geospatial location.
type GeoLocation struct {
        Name                      string
        Longitude, Latitude, Dist float64
        GeoHash                   int64
}

// GeoRadiusQuery is used with GeoRadius to query geospatial index.
type GeoRadiusQuery struct {
        Radius float64
        // Can be m, km, ft, or mi. Default is km.
        Unit        string
        WithCoord   bool
        WithDist    bool
        WithGeoHash bool
        Count       int
        // Can be ASC or DESC. Default is no sort order.
        Sort      string
        Store     string
        StoreDist string

        // WithCoord+WithDist+WithGeoHash
        withLen int
}

type GeoLocationCmd struct {
        baseCmd

        q         *GeoRadiusQuery
        locations []GeoLocation
}

var _ Cmder = (*GeoLocationCmd)(nil)

func NewGeoLocationCmd(ctx context.Context, q *GeoRadiusQuery, args ...interface{}) *GeoLocationCmd {
        return &GeoLocationCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: geoLocationArgs(q, args...),
                },
                q: q,
        }
}

func geoLocationArgs(q *GeoRadiusQuery, args ...interface{}) []interface{} {
        args = append(args, q.Radius)
        if q.Unit != "" {
                args = append(args, q.Unit)
        } else {
                args = append(args, "km")
        }
        if q.WithCoord {
                args = append(args, "withcoord")
                q.withLen++
        }
        if q.WithDist {
                args = append(args, "withdist")
                q.withLen++
        }
        if q.WithGeoHash {
                args = append(args, "withhash")
                q.withLen++
        }
        if q.Count > 0 {
                args = append(args, "count", q.Count)
        }
        if q.Sort != "" {
                args = append(args, q.Sort)
        }
        if q.Store != "" {
                args = append(args, "store")
                args = append(args, q.Store)
        }
        if q.StoreDist != "" {
                args = append(args, "storedist")
                args = append(args, q.StoreDist)
        }
        return args
}

func (cmd *GeoLocationCmd) SetVal(locations []GeoLocation) {
        cmd.locations = locations
}

func (cmd *GeoLocationCmd) Val() []GeoLocation {
        return cmd.locations
}

func (cmd *GeoLocationCmd) Result() ([]GeoLocation, error) {
        return cmd.locations, cmd.err
}

func (cmd *GeoLocationCmd) String() string {
        return cmdString(cmd, cmd.locations)
}

func (cmd *GeoLocationCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.locations = make([]GeoLocation, n)

        for i := 0; i < len(cmd.locations); i++ {
                // only name
                if cmd.q.withLen == 0 {
                        if cmd.locations[i].Name, err = rd.ReadString(); err != nil {
                                return err
                        }
                        continue
                }

                // +name
                if err = rd.ReadFixedArrayLen(cmd.q.withLen + 1); err != nil {
                        return err
                }

                if cmd.locations[i].Name, err = rd.ReadString(); err != nil {
                        return err
                }
                if cmd.q.WithDist {
                        if cmd.locations[i].Dist, err = rd.ReadFloat(); err != nil {
                                return err
                        }
                }
                if cmd.q.WithGeoHash {
                        if cmd.locations[i].GeoHash, err = rd.ReadInt(); err != nil {
                                return err
                        }
                }
                if cmd.q.WithCoord {
                        if err = rd.ReadFixedArrayLen(2); err != nil {
                                return err
                        }
                        if cmd.locations[i].Longitude, err = rd.ReadFloat(); err != nil {
                                return err
                        }
                        if cmd.locations[i].Latitude, err = rd.ReadFloat(); err != nil {
                                return err
                        }
                }
        }

        return nil
}

//------------------------------------------------------------------------------

// GeoSearchQuery is used for GEOSearch/GEOSearchStore command query.
type GeoSearchQuery struct {
        Member string

        // Latitude and Longitude when using FromLonLat option.
        Longitude float64
        Latitude  float64

        // Distance and unit when using ByRadius option.
        // Can use m, km, ft, or mi. Default is km.
        Radius     float64
        RadiusUnit string

        // Height, width and unit when using ByBox option.
        // Can be m, km, ft, or mi. Default is km.
        BoxWidth  float64
        BoxHeight float64
        BoxUnit   string

        // Can be ASC or DESC. Default is no sort order.
        Sort     string
        Count    int
        CountAny bool
}

type GeoSearchLocationQuery struct {
        GeoSearchQuery

        WithCoord bool
        WithDist  bool
        WithHash  bool
}

type GeoSearchStoreQuery struct {
        GeoSearchQuery

        // When using the StoreDist option, the command stores the items in a
        // sorted set populated with their distance from the center of the circle or box,
        // as a floating-point number, in the same unit specified for that shape.
        StoreDist bool
}

func geoSearchLocationArgs(q *GeoSearchLocationQuery, args []interface{}) []interface{} {
        args = geoSearchArgs(&q.GeoSearchQuery, args)

        if q.WithCoord {
                args = append(args, "withcoord")
        }
        if q.WithDist {
                args = append(args, "withdist")
        }
        if q.WithHash {
                args = append(args, "withhash")
        }

        return args
}

func geoSearchArgs(q *GeoSearchQuery, args []interface{}) []interface{} {
        if q.Member != "" {
                args = append(args, "frommember", q.Member)
        } else {
                args = append(args, "fromlonlat", q.Longitude, q.Latitude)
        }

        if q.Radius > 0 {
                if q.RadiusUnit == "" {
                        q.RadiusUnit = "km"
                }
                args = append(args, "byradius", q.Radius, q.RadiusUnit)
        } else {
                if q.BoxUnit == "" {
                        q.BoxUnit = "km"
                }
                args = append(args, "bybox", q.BoxWidth, q.BoxHeight, q.BoxUnit)
        }

        if q.Sort != "" {
                args = append(args, q.Sort)
        }

        if q.Count > 0 {
                args = append(args, "count", q.Count)
                if q.CountAny {
                        args = append(args, "any")
                }
        }

        return args
}

type GeoSearchLocationCmd struct {
        baseCmd

        opt *GeoSearchLocationQuery
        val []GeoLocation
}

var _ Cmder = (*GeoSearchLocationCmd)(nil)

func NewGeoSearchLocationCmd(
        ctx context.Context, opt *GeoSearchLocationQuery, args ...interface{},
) *GeoSearchLocationCmd {
        return &GeoSearchLocationCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
                opt: opt,
        }
}

func (cmd *GeoSearchLocationCmd) SetVal(val []GeoLocation) {
        cmd.val = val
}

func (cmd *GeoSearchLocationCmd) Val() []GeoLocation {
        return cmd.val
}

func (cmd *GeoSearchLocationCmd) Result() ([]GeoLocation, error) {
        return cmd.val, cmd.err
}

func (cmd *GeoSearchLocationCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *GeoSearchLocationCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        cmd.val = make([]GeoLocation, n)
        for i := 0; i < n; i++ {
                _, err = rd.ReadArrayLen()
                if err != nil {
                        return err
                }

                var loc GeoLocation

                loc.Name, err = rd.ReadString()
                if err != nil {
                        return err
                }
                if cmd.opt.WithDist {
                        loc.Dist, err = rd.ReadFloat()
                        if err != nil {
                                return err
                        }
                }
                if cmd.opt.WithHash {
                        loc.GeoHash, err = rd.ReadInt()
                        if err != nil {
                                return err
                        }
                }
                if cmd.opt.WithCoord {
                        if err = rd.ReadFixedArrayLen(2); err != nil {
                                return err
                        }
                        loc.Longitude, err = rd.ReadFloat()
                        if err != nil {
                                return err
                        }
                        loc.Latitude, err = rd.ReadFloat()
                        if err != nil {
                                return err
                        }
                }

                cmd.val[i] = loc
        }

        return nil
}

//------------------------------------------------------------------------------

type GeoPos struct {
        Longitude, Latitude float64
}

type GeoPosCmd struct {
        baseCmd

        val []*GeoPos
}

var _ Cmder = (*GeoPosCmd)(nil)

func NewGeoPosCmd(ctx context.Context, args ...interface{}) *GeoPosCmd {
        return &GeoPosCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *GeoPosCmd) SetVal(val []*GeoPos) {
        cmd.val = val
}

func (cmd *GeoPosCmd) Val() []*GeoPos {
        return cmd.val
}

func (cmd *GeoPosCmd) Result() ([]*GeoPos, error) {
        return cmd.val, cmd.err
}

func (cmd *GeoPosCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *GeoPosCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]*GeoPos, n)

        for i := 0; i < len(cmd.val); i++ {
                err = rd.ReadFixedArrayLen(2)
                if err != nil {
                        if err == Nil {
                                cmd.val[i] = nil
                                continue
                        }
                        return err
                }

                longitude, err := rd.ReadFloat()
                if err != nil {
                        return err
                }
                latitude, err := rd.ReadFloat()
                if err != nil {
                        return err
                }

                cmd.val[i] = &GeoPos{
                        Longitude: longitude,
                        Latitude:  latitude,
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type CommandInfo struct {
        Name        string
        Arity       int8
        Flags       []string
        ACLFlags    []string
        FirstKeyPos int8
        LastKeyPos  int8
        StepCount   int8
        ReadOnly    bool
}

type CommandsInfoCmd struct {
        baseCmd

        val map[string]*CommandInfo
}

var _ Cmder = (*CommandsInfoCmd)(nil)

func NewCommandsInfoCmd(ctx context.Context, args ...interface{}) *CommandsInfoCmd {
        return &CommandsInfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *CommandsInfoCmd) SetVal(val map[string]*CommandInfo) {
        cmd.val = val
}

func (cmd *CommandsInfoCmd) Val() map[string]*CommandInfo {
        return cmd.val
}

func (cmd *CommandsInfoCmd) Result() (map[string]*CommandInfo, error) {
        return cmd.val, cmd.err
}

func (cmd *CommandsInfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *CommandsInfoCmd) readReply(rd *proto.Reader) error {
        const numArgRedis5 = 6
        const numArgRedis6 = 7
        const numArgRedis7 = 10

        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make(map[string]*CommandInfo, n)

        for i := 0; i < n; i++ {
                nn, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }

                switch nn {
                case numArgRedis5, numArgRedis6, numArgRedis7:
                        // ok
                default:
                        return fmt.Errorf("redis: got %d elements in COMMAND reply, wanted 6/7/10", nn)
                }

                cmdInfo := &CommandInfo{}
                if cmdInfo.Name, err = rd.ReadString(); err != nil {
                        return err
                }

                arity, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                cmdInfo.Arity = int8(arity)

                flagLen, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }
                cmdInfo.Flags = make([]string, flagLen)
                for f := 0; f < len(cmdInfo.Flags); f++ {
                        switch s, err := rd.ReadString(); {
                        case err == Nil:
                                cmdInfo.Flags[f] = ""
                        case err != nil:
                                return err
                        default:
                                if !cmdInfo.ReadOnly && s == "readonly" {
                                        cmdInfo.ReadOnly = true
                                }
                                cmdInfo.Flags[f] = s
                        }
                }

                firstKeyPos, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                cmdInfo.FirstKeyPos = int8(firstKeyPos)

                lastKeyPos, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                cmdInfo.LastKeyPos = int8(lastKeyPos)

                stepCount, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                cmdInfo.StepCount = int8(stepCount)

                if nn >= numArgRedis6 {
                        aclFlagLen, err := rd.ReadArrayLen()
                        if err != nil {
                                return err
                        }
                        cmdInfo.ACLFlags = make([]string, aclFlagLen)
                        for f := 0; f < len(cmdInfo.ACLFlags); f++ {
                                switch s, err := rd.ReadString(); {
                                case err == Nil:
                                        cmdInfo.ACLFlags[f] = ""
                                case err != nil:
                                        return err
                                default:
                                        cmdInfo.ACLFlags[f] = s
                                }
                        }
                }

                if nn >= numArgRedis7 {
                        if err := rd.DiscardNext(); err != nil {
                                return err
                        }
                        if err := rd.DiscardNext(); err != nil {
                                return err
                        }
                        if err := rd.DiscardNext(); err != nil {
                                return err
                        }
                }

                cmd.val[cmdInfo.Name] = cmdInfo
        }

        return nil
}

//------------------------------------------------------------------------------

type cmdsInfoCache struct {
        fn func(ctx context.Context) (map[string]*CommandInfo, error)

        once internal.Once
        cmds map[string]*CommandInfo
}

func newCmdsInfoCache(fn func(ctx context.Context) (map[string]*CommandInfo, error)) *cmdsInfoCache {
        return &cmdsInfoCache{
                fn: fn,
        }
}

func (c *cmdsInfoCache) Get(ctx context.Context) (map[string]*CommandInfo, error) {
        err := c.once.Do(func() error {
                cmds, err := c.fn(ctx)
                if err != nil {
                        return err
                }

                lowerCmds := make(map[string]*CommandInfo, len(cmds))

                // Extensions have cmd names in upper case. Convert them to lower case.
                for k, v := range cmds {
                        lowerCmds[internal.ToLower(k)] = v
                }

                c.cmds = lowerCmds
                return nil
        })
        return c.cmds, err
}

//------------------------------------------------------------------------------

type SlowLog struct {
        ID       int64
        Time     time.Time
        Duration time.Duration
        Args     []string
        // These are also optional fields emitted only by Redis 4.0 or greater:
        // https://redis.io/commands/slowlog#output-format
        ClientAddr string
        ClientName string
}

type SlowLogCmd struct {
        baseCmd

        val []SlowLog
}

var _ Cmder = (*SlowLogCmd)(nil)

func NewSlowLogCmd(ctx context.Context, args ...interface{}) *SlowLogCmd {
        return &SlowLogCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *SlowLogCmd) SetVal(val []SlowLog) {
        cmd.val = val
}

func (cmd *SlowLogCmd) Val() []SlowLog {
        return cmd.val
}

func (cmd *SlowLogCmd) Result() ([]SlowLog, error) {
        return cmd.val, cmd.err
}

func (cmd *SlowLogCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *SlowLogCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]SlowLog, n)

        for i := 0; i < len(cmd.val); i++ {
                nn, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }
                if nn < 4 {
                        return fmt.Errorf("redis: got %d elements in slowlog get, expected at least 4", nn)
                }

                if cmd.val[i].ID, err = rd.ReadInt(); err != nil {
                        return err
                }

                createdAt, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                cmd.val[i].Time = time.Unix(createdAt, 0)

                costs, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                cmd.val[i].Duration = time.Duration(costs) * time.Microsecond

                cmdLen, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }
                if cmdLen < 1 {
                        return fmt.Errorf("redis: got %d elements commands reply in slowlog get, expected at least 1", cmdLen)
                }

                cmd.val[i].Args = make([]string, cmdLen)
                for f := 0; f < len(cmd.val[i].Args); f++ {
                        cmd.val[i].Args[f], err = rd.ReadString()
                        if err != nil {
                                return err
                        }
                }

                if nn >= 5 {
                        if cmd.val[i].ClientAddr, err = rd.ReadString(); err != nil {
                                return err
                        }
                }

                if nn >= 6 {
                        if cmd.val[i].ClientName, err = rd.ReadString(); err != nil {
                                return err
                        }
                }
        }

        return nil
}

//-----------------------------------------------------------------------

type MapStringInterfaceCmd struct {
        baseCmd

        val map[string]interface{}
}

var _ Cmder = (*MapStringInterfaceCmd)(nil)

func NewMapStringInterfaceCmd(ctx context.Context, args ...interface{}) *MapStringInterfaceCmd {
        return &MapStringInterfaceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *MapStringInterfaceCmd) SetVal(val map[string]interface{}) {
        cmd.val = val
}

func (cmd *MapStringInterfaceCmd) Val() map[string]interface{} {
        return cmd.val
}

func (cmd *MapStringInterfaceCmd) Result() (map[string]interface{}, error) {
        return cmd.val, cmd.err
}

func (cmd *MapStringInterfaceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *MapStringInterfaceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        cmd.val = make(map[string]interface{}, n)
        for i := 0; i < n; i++ {
                k, err := rd.ReadString()
                if err != nil {
                        return err
                }
                v, err := rd.ReadReply()
                if err != nil {
                        if err == Nil {
                                cmd.val[k] = Nil
                                continue
                        }
                        if err, ok := err.(proto.RedisError); ok {
                                cmd.val[k] = err
                                continue
                        }
                        return err
                }
                cmd.val[k] = v
        }
        return nil
}

//-----------------------------------------------------------------------

type MapStringStringSliceCmd struct {
        baseCmd

        val []map[string]string
}

var _ Cmder = (*MapStringStringSliceCmd)(nil)

func NewMapStringStringSliceCmd(ctx context.Context, args ...interface{}) *MapStringStringSliceCmd {
        return &MapStringStringSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *MapStringStringSliceCmd) SetVal(val []map[string]string) {
        cmd.val = val
}

func (cmd *MapStringStringSliceCmd) Val() []map[string]string {
        return cmd.val
}

func (cmd *MapStringStringSliceCmd) Result() ([]map[string]string, error) {
        return cmd.val, cmd.err
}

func (cmd *MapStringStringSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *MapStringStringSliceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        cmd.val = make([]map[string]string, n)
        for i := 0; i < n; i++ {
                nn, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }
                cmd.val[i] = make(map[string]string, nn)
                for f := 0; f < nn; f++ {
                        k, err := rd.ReadString()
                        if err != nil {
                                return err
                        }

                        v, err := rd.ReadString()
                        if err != nil {
                                return err
                        }
                        cmd.val[i][k] = v
                }
        }
        return nil
}

// -----------------------------------------------------------------------

// MapMapStringInterfaceCmd represents a command that returns a map of strings to interface{}.
type MapMapStringInterfaceCmd struct {
        baseCmd
        val map[string]interface{}
}

func NewMapMapStringInterfaceCmd(ctx context.Context, args ...interface{}) *MapMapStringInterfaceCmd {
        return &MapMapStringInterfaceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *MapMapStringInterfaceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *MapMapStringInterfaceCmd) SetVal(val map[string]interface{}) {
        cmd.val = val
}

func (cmd *MapMapStringInterfaceCmd) Result() (map[string]interface{}, error) {
        return cmd.val, cmd.err
}

func (cmd *MapMapStringInterfaceCmd) Val() map[string]interface{} {
        return cmd.val
}

// readReply will try to parse the reply from the proto.Reader for both resp2 and resp3
func (cmd *MapMapStringInterfaceCmd) readReply(rd *proto.Reader) (err error) {
        data, err := rd.ReadReply()
        if err != nil {
                return err
        }
        resultMap := map[string]interface{}{}

        switch midResponse := data.(type) {
        case map[interface{}]interface{}: // resp3 will return map
                for k, v := range midResponse {
                        stringKey, ok := k.(string)
                        if !ok {
                                return fmt.Errorf("redis: invalid map key %#v", k)
                        }
                        resultMap[stringKey] = v
                }
        case []interface{}: // resp2 will return array of arrays
                n := len(midResponse)
                for i := 0; i < n; i++ {
                        finalArr, ok := midResponse[i].([]interface{}) // final array that we need to transform to map
                        if !ok {
                                return fmt.Errorf("redis: unexpected response %#v", data)
                        }
                        m := len(finalArr)
                        if m%2 != 0 { // since this should be map, keys should be even number
                                return fmt.Errorf("redis: unexpected response %#v", data)
                        }

                        for j := 0; j < m; j += 2 {
                                stringKey, ok := finalArr[j].(string) // the first one
                                if !ok {
                                        return fmt.Errorf("redis: invalid map key %#v", finalArr[i])
                                }
                                resultMap[stringKey] = finalArr[j+1] // second one is value
                        }
                }
        default:
                return fmt.Errorf("redis: unexpected response %#v", data)
        }

        cmd.val = resultMap
        return nil
}

//-----------------------------------------------------------------------

type MapStringInterfaceSliceCmd struct {
        baseCmd

        val []map[string]interface{}
}

var _ Cmder = (*MapStringInterfaceSliceCmd)(nil)

func NewMapStringInterfaceSliceCmd(ctx context.Context, args ...interface{}) *MapStringInterfaceSliceCmd {
        return &MapStringInterfaceSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *MapStringInterfaceSliceCmd) SetVal(val []map[string]interface{}) {
        cmd.val = val
}

func (cmd *MapStringInterfaceSliceCmd) Val() []map[string]interface{} {
        return cmd.val
}

func (cmd *MapStringInterfaceSliceCmd) Result() ([]map[string]interface{}, error) {
        return cmd.val, cmd.err
}

func (cmd *MapStringInterfaceSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *MapStringInterfaceSliceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        cmd.val = make([]map[string]interface{}, n)
        for i := 0; i < n; i++ {
                nn, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }
                cmd.val[i] = make(map[string]interface{}, nn)
                for f := 0; f < nn; f++ {
                        k, err := rd.ReadString()
                        if err != nil {
                                return err
                        }
                        v, err := rd.ReadReply()
                        if err != nil {
                                if err != Nil {
                                        return err
                                }
                        }
                        cmd.val[i][k] = v
                }
        }
        return nil
}

//------------------------------------------------------------------------------

type KeyValuesCmd struct {
        baseCmd

        key string
        val []string
}

var _ Cmder = (*KeyValuesCmd)(nil)

func NewKeyValuesCmd(ctx context.Context, args ...interface{}) *KeyValuesCmd {
        return &KeyValuesCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *KeyValuesCmd) SetVal(key string, val []string) {
        cmd.key = key
        cmd.val = val
}

func (cmd *KeyValuesCmd) Val() (string, []string) {
        return cmd.key, cmd.val
}

func (cmd *KeyValuesCmd) Result() (string, []string, error) {
        return cmd.key, cmd.val, cmd.err
}

func (cmd *KeyValuesCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *KeyValuesCmd) readReply(rd *proto.Reader) (err error) {
        if err = rd.ReadFixedArrayLen(2); err != nil {
                return err
        }

        cmd.key, err = rd.ReadString()
        if err != nil {
                return err
        }

        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]string, n)
        for i := 0; i < n; i++ {
                cmd.val[i], err = rd.ReadString()
                if err != nil {
                        return err
                }
        }

        return nil
}

//------------------------------------------------------------------------------

type ZSliceWithKeyCmd struct {
        baseCmd

        key string
        val []Z
}

var _ Cmder = (*ZSliceWithKeyCmd)(nil)

func NewZSliceWithKeyCmd(ctx context.Context, args ...interface{}) *ZSliceWithKeyCmd {
        return &ZSliceWithKeyCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ZSliceWithKeyCmd) SetVal(key string, val []Z) {
        cmd.key = key
        cmd.val = val
}

func (cmd *ZSliceWithKeyCmd) Val() (string, []Z) {
        return cmd.key, cmd.val
}

func (cmd *ZSliceWithKeyCmd) Result() (string, []Z, error) {
        return cmd.key, cmd.val, cmd.err
}

func (cmd *ZSliceWithKeyCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ZSliceWithKeyCmd) readReply(rd *proto.Reader) (err error) {
        if err = rd.ReadFixedArrayLen(2); err != nil {
                return err
        }

        cmd.key, err = rd.ReadString()
        if err != nil {
                return err
        }

        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        typ, err := rd.PeekReplyType()
        if err != nil {
                return err
        }
        array := typ == proto.RespArray

        if array {
                cmd.val = make([]Z, n)
        } else {
                cmd.val = make([]Z, n/2)
        }

        for i := 0; i < len(cmd.val); i++ {
                if array {
                        if err = rd.ReadFixedArrayLen(2); err != nil {
                                return err
                        }
                }

                if cmd.val[i].Member, err = rd.ReadString(); err != nil {
                        return err
                }

                if cmd.val[i].Score, err = rd.ReadFloat(); err != nil {
                        return err
                }
        }

        return nil
}

type Function struct {
        Name        string
        Description string
        Flags       []string
}

type Library struct {
        Name      string
        Engine    string
        Functions []Function
        Code      string
}

type FunctionListCmd struct {
        baseCmd

        val []Library
}

var _ Cmder = (*FunctionListCmd)(nil)

func NewFunctionListCmd(ctx context.Context, args ...interface{}) *FunctionListCmd {
        return &FunctionListCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *FunctionListCmd) SetVal(val []Library) {
        cmd.val = val
}

func (cmd *FunctionListCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *FunctionListCmd) Val() []Library {
        return cmd.val
}

func (cmd *FunctionListCmd) Result() ([]Library, error) {
        return cmd.val, cmd.err
}

func (cmd *FunctionListCmd) First() (*Library, error) {
        if cmd.err != nil {
                return nil, cmd.err
        }
        if len(cmd.val) > 0 {
                return &cmd.val[0], nil
        }
        return nil, Nil
}

func (cmd *FunctionListCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        libraries := make([]Library, n)
        for i := 0; i < n; i++ {
                nn, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }

                library := Library{}
                for f := 0; f < nn; f++ {
                        key, err := rd.ReadString()
                        if err != nil {
                                return err
                        }

                        switch key {
                        case "library_name":
                                library.Name, err = rd.ReadString()
                        case "engine":
                                library.Engine, err = rd.ReadString()
                        case "functions":
                                library.Functions, err = cmd.readFunctions(rd)
                        case "library_code":
                                library.Code, err = rd.ReadString()
                        default:
                                return fmt.Errorf("redis: function list unexpected key %s", key)
                        }

                        if err != nil {
                                return err
                        }
                }

                libraries[i] = library
        }
        cmd.val = libraries
        return nil
}

func (cmd *FunctionListCmd) readFunctions(rd *proto.Reader) ([]Function, error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return nil, err
        }

        functions := make([]Function, n)
        for i := 0; i < n; i++ {
                nn, err := rd.ReadMapLen()
                if err != nil {
                        return nil, err
                }

                function := Function{}
                for f := 0; f < nn; f++ {
                        key, err := rd.ReadString()
                        if err != nil {
                                return nil, err
                        }

                        switch key {
                        case "name":
                                if function.Name, err = rd.ReadString(); err != nil {
                                        return nil, err
                                }
                        case "description":
                                if function.Description, err = rd.ReadString(); err != nil && err != Nil {
                                        return nil, err
                                }
                        case "flags":
                                // resp set
                                nx, err := rd.ReadArrayLen()
                                if err != nil {
                                        return nil, err
                                }

                                function.Flags = make([]string, nx)
                                for j := 0; j < nx; j++ {
                                        if function.Flags[j], err = rd.ReadString(); err != nil {
                                                return nil, err
                                        }
                                }
                        default:
                                return nil, fmt.Errorf("redis: function list unexpected key %s", key)
                        }
                }

                functions[i] = function
        }
        return functions, nil
}

// FunctionStats contains information about the scripts currently executing on the server, and the available engines
//   - Engines:
//     Statistics about the engine like number of functions and number of libraries
//   - RunningScript:
//     The script currently running on the shard we're connecting to.
//     For Redis Enterprise and Redis Cloud, this represents the
//     function with the longest running time, across all the running functions, on all shards
//   - RunningScripts
//     All scripts currently running in a Redis Enterprise clustered database.
//     Only available on Redis Enterprise
type FunctionStats struct {
        Engines   []Engine
        isRunning bool
        rs        RunningScript
        allrs     []RunningScript
}

func (fs *FunctionStats) Running() bool {
        return fs.isRunning
}

func (fs *FunctionStats) RunningScript() (RunningScript, bool) {
        return fs.rs, fs.isRunning
}

// AllRunningScripts returns all scripts currently running in a Redis Enterprise clustered database.
// Only available on Redis Enterprise
func (fs *FunctionStats) AllRunningScripts() []RunningScript {
        return fs.allrs
}

type RunningScript struct {
        Name     string
        Command  []string
        Duration time.Duration
}

type Engine struct {
        Language       string
        LibrariesCount int64
        FunctionsCount int64
}

type FunctionStatsCmd struct {
        baseCmd
        val FunctionStats
}

var _ Cmder = (*FunctionStatsCmd)(nil)

func NewFunctionStatsCmd(ctx context.Context, args ...interface{}) *FunctionStatsCmd {
        return &FunctionStatsCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *FunctionStatsCmd) SetVal(val FunctionStats) {
        cmd.val = val
}

func (cmd *FunctionStatsCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *FunctionStatsCmd) Val() FunctionStats {
        return cmd.val
}

func (cmd *FunctionStatsCmd) Result() (FunctionStats, error) {
        return cmd.val, cmd.err
}

func (cmd *FunctionStatsCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        var key string
        var result FunctionStats
        for f := 0; f < n; f++ {
                key, err = rd.ReadString()
                if err != nil {
                        return err
                }

                switch key {
                case "running_script":
                        result.rs, result.isRunning, err = cmd.readRunningScript(rd)
                case "engines":
                        result.Engines, err = cmd.readEngines(rd)
                case "all_running_scripts": // Redis Enterprise only
                        result.allrs, result.isRunning, err = cmd.readRunningScripts(rd)
                default:
                        return fmt.Errorf("redis: function stats unexpected key %s", key)
                }

                if err != nil {
                        return err
                }
        }

        cmd.val = result
        return nil
}

func (cmd *FunctionStatsCmd) readRunningScript(rd *proto.Reader) (RunningScript, bool, error) {
        err := rd.ReadFixedMapLen(3)
        if err != nil {
                if err == Nil {
                        return RunningScript{}, false, nil
                }
                return RunningScript{}, false, err
        }

        var runningScript RunningScript
        for i := 0; i < 3; i++ {
                key, err := rd.ReadString()
                if err != nil {
                        return RunningScript{}, false, err
                }

                switch key {
                case "name":
                        runningScript.Name, err = rd.ReadString()
                case "duration_ms":
                        runningScript.Duration, err = cmd.readDuration(rd)
                case "command":
                        runningScript.Command, err = cmd.readCommand(rd)
                default:
                        return RunningScript{}, false, fmt.Errorf("redis: function stats unexpected running_script key %s", key)
                }

                if err != nil {
                        return RunningScript{}, false, err
                }
        }

        return runningScript, true, nil
}

func (cmd *FunctionStatsCmd) readEngines(rd *proto.Reader) ([]Engine, error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return nil, err
        }

        engines := make([]Engine, 0, n)
        for i := 0; i < n; i++ {
                engine := Engine{}
                engine.Language, err = rd.ReadString()
                if err != nil {
                        return nil, err
                }

                err = rd.ReadFixedMapLen(2)
                if err != nil {
                        return nil, fmt.Errorf("redis: function stats unexpected %s engine map length", engine.Language)
                }

                for i := 0; i < 2; i++ {
                        key, err := rd.ReadString()
                        switch key {
                        case "libraries_count":
                                engine.LibrariesCount, err = rd.ReadInt()
                        case "functions_count":
                                engine.FunctionsCount, err = rd.ReadInt()
                        }
                        if err != nil {
                                return nil, err
                        }
                }

                engines = append(engines, engine)
        }
        return engines, nil
}

func (cmd *FunctionStatsCmd) readDuration(rd *proto.Reader) (time.Duration, error) {
        t, err := rd.ReadInt()
        if err != nil {
                return time.Duration(0), err
        }
        return time.Duration(t) * time.Millisecond, nil
}

func (cmd *FunctionStatsCmd) readCommand(rd *proto.Reader) ([]string, error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return nil, err
        }

        command := make([]string, 0, n)
        for i := 0; i < n; i++ {
                x, err := rd.ReadString()
                if err != nil {
                        return nil, err
                }
                command = append(command, x)
        }

        return command, nil
}

func (cmd *FunctionStatsCmd) readRunningScripts(rd *proto.Reader) ([]RunningScript, bool, error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return nil, false, err
        }

        runningScripts := make([]RunningScript, 0, n)
        for i := 0; i < n; i++ {
                rs, _, err := cmd.readRunningScript(rd)
                if err != nil {
                        return nil, false, err
                }
                runningScripts = append(runningScripts, rs)
        }

        return runningScripts, len(runningScripts) > 0, nil
}

//------------------------------------------------------------------------------

// LCSQuery is a parameter used for the LCS command
type LCSQuery struct {
        Key1         string
        Key2         string
        Len          bool
        Idx          bool
        MinMatchLen  int
        WithMatchLen bool
}

// LCSMatch is the result set of the LCS command.
type LCSMatch struct {
        MatchString string
        Matches     []LCSMatchedPosition
        Len         int64
}

type LCSMatchedPosition struct {
        Key1 LCSPosition
        Key2 LCSPosition

        // only for withMatchLen is true
        MatchLen int64
}

type LCSPosition struct {
        Start int64
        End   int64
}

type LCSCmd struct {
        baseCmd

        // 1: match string
        // 2: match len
        // 3: match idx LCSMatch
        readType uint8
        val      *LCSMatch
}

func NewLCSCmd(ctx context.Context, q *LCSQuery) *LCSCmd {
        args := make([]interface{}, 3, 7)
        args[0] = "lcs"
        args[1] = q.Key1
        args[2] = q.Key2

        cmd := &LCSCmd{readType: 1}
        if q.Len {
                cmd.readType = 2
                args = append(args, "len")
        } else if q.Idx {
                cmd.readType = 3
                args = append(args, "idx")
                if q.MinMatchLen != 0 {
                        args = append(args, "minmatchlen", q.MinMatchLen)
                }
                if q.WithMatchLen {
                        args = append(args, "withmatchlen")
                }
        }
        cmd.baseCmd = baseCmd{
                ctx:  ctx,
                args: args,
        }

        return cmd
}

func (cmd *LCSCmd) SetVal(val *LCSMatch) {
        cmd.val = val
}

func (cmd *LCSCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *LCSCmd) Val() *LCSMatch {
        return cmd.val
}

func (cmd *LCSCmd) Result() (*LCSMatch, error) {
        return cmd.val, cmd.err
}

func (cmd *LCSCmd) readReply(rd *proto.Reader) (err error) {
        lcs := &LCSMatch{}
        switch cmd.readType {
        case 1:
                // match string
                if lcs.MatchString, err = rd.ReadString(); err != nil {
                        return err
                }
        case 2:
                // match len
                if lcs.Len, err = rd.ReadInt(); err != nil {
                        return err
                }
        case 3:
                // read LCSMatch
                if err = rd.ReadFixedMapLen(2); err != nil {
                        return err
                }

                // read matches or len field
                for i := 0; i < 2; i++ {
                        key, err := rd.ReadString()
                        if err != nil {
                                return err
                        }

                        switch key {
                        case "matches":
                                // read array of matched positions
                                if lcs.Matches, err = cmd.readMatchedPositions(rd); err != nil {
                                        return err
                                }
                        case "len":
                                // read match length
                                if lcs.Len, err = rd.ReadInt(); err != nil {
                                        return err
                                }
                        }
                }
        }

        cmd.val = lcs
        return nil
}

func (cmd *LCSCmd) readMatchedPositions(rd *proto.Reader) ([]LCSMatchedPosition, error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return nil, err
        }

        positions := make([]LCSMatchedPosition, n)
        for i := 0; i < n; i++ {
                pn, err := rd.ReadArrayLen()
                if err != nil {
                        return nil, err
                }

                if positions[i].Key1, err = cmd.readPosition(rd); err != nil {
                        return nil, err
                }
                if positions[i].Key2, err = cmd.readPosition(rd); err != nil {
                        return nil, err
                }

                // read match length if WithMatchLen is true
                if pn > 2 {
                        if positions[i].MatchLen, err = rd.ReadInt(); err != nil {
                                return nil, err
                        }
                }
        }

        return positions, nil
}

func (cmd *LCSCmd) readPosition(rd *proto.Reader) (pos LCSPosition, err error) {
        if err = rd.ReadFixedArrayLen(2); err != nil {
                return pos, err
        }
        if pos.Start, err = rd.ReadInt(); err != nil {
                return pos, err
        }
        if pos.End, err = rd.ReadInt(); err != nil {
                return pos, err
        }

        return pos, nil
}

// ------------------------------------------------------------------------

type KeyFlags struct {
        Key   string
        Flags []string
}

type KeyFlagsCmd struct {
        baseCmd

        val []KeyFlags
}

var _ Cmder = (*KeyFlagsCmd)(nil)

func NewKeyFlagsCmd(ctx context.Context, args ...interface{}) *KeyFlagsCmd {
        return &KeyFlagsCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *KeyFlagsCmd) SetVal(val []KeyFlags) {
        cmd.val = val
}

func (cmd *KeyFlagsCmd) Val() []KeyFlags {
        return cmd.val
}

func (cmd *KeyFlagsCmd) Result() ([]KeyFlags, error) {
        return cmd.val, cmd.err
}

func (cmd *KeyFlagsCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *KeyFlagsCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        if n == 0 {
                cmd.val = make([]KeyFlags, 0)
                return nil
        }

        cmd.val = make([]KeyFlags, n)

        for i := 0; i < len(cmd.val); i++ {

                if err = rd.ReadFixedArrayLen(2); err != nil {
                        return err
                }

                if cmd.val[i].Key, err = rd.ReadString(); err != nil {
                        return err
                }
                flagsLen, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }
                cmd.val[i].Flags = make([]string, flagsLen)

                for j := 0; j < flagsLen; j++ {
                        if cmd.val[i].Flags[j], err = rd.ReadString(); err != nil {
                                return err
                        }
                }
        }

        return nil
}

// ---------------------------------------------------------------------------------------------------

type ClusterLink struct {
        Direction           string
        Node                string
        CreateTime          int64
        Events              string
        SendBufferAllocated int64
        SendBufferUsed      int64
}

type ClusterLinksCmd struct {
        baseCmd

        val []ClusterLink
}

var _ Cmder = (*ClusterLinksCmd)(nil)

func NewClusterLinksCmd(ctx context.Context, args ...interface{}) *ClusterLinksCmd {
        return &ClusterLinksCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ClusterLinksCmd) SetVal(val []ClusterLink) {
        cmd.val = val
}

func (cmd *ClusterLinksCmd) Val() []ClusterLink {
        return cmd.val
}

func (cmd *ClusterLinksCmd) Result() ([]ClusterLink, error) {
        return cmd.val, cmd.err
}

func (cmd *ClusterLinksCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ClusterLinksCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]ClusterLink, n)

        for i := 0; i < len(cmd.val); i++ {
                m, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }

                for j := 0; j < m; j++ {
                        key, err := rd.ReadString()
                        if err != nil {
                                return err
                        }

                        switch key {
                        case "direction":
                                cmd.val[i].Direction, err = rd.ReadString()
                        case "node":
                                cmd.val[i].Node, err = rd.ReadString()
                        case "create-time":
                                cmd.val[i].CreateTime, err = rd.ReadInt()
                        case "events":
                                cmd.val[i].Events, err = rd.ReadString()
                        case "send-buffer-allocated":
                                cmd.val[i].SendBufferAllocated, err = rd.ReadInt()
                        case "send-buffer-used":
                                cmd.val[i].SendBufferUsed, err = rd.ReadInt()
                        default:
                                return fmt.Errorf("redis: unexpected key %q in CLUSTER LINKS reply", key)
                        }

                        if err != nil {
                                return err
                        }
                }
        }

        return nil
}

// ------------------------------------------------------------------------------------------------------------------

type SlotRange struct {
        Start int64
        End   int64
}

type Node struct {
        ID                string
        Endpoint          string
        IP                string
        Hostname          string
        Port              int64
        TLSPort           int64
        Role              string
        ReplicationOffset int64
        Health            string
}

type ClusterShard struct {
        Slots []SlotRange
        Nodes []Node
}

type ClusterShardsCmd struct {
        baseCmd

        val []ClusterShard
}

var _ Cmder = (*ClusterShardsCmd)(nil)

func NewClusterShardsCmd(ctx context.Context, args ...interface{}) *ClusterShardsCmd {
        return &ClusterShardsCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ClusterShardsCmd) SetVal(val []ClusterShard) {
        cmd.val = val
}

func (cmd *ClusterShardsCmd) Val() []ClusterShard {
        return cmd.val
}

func (cmd *ClusterShardsCmd) Result() ([]ClusterShard, error) {
        return cmd.val, cmd.err
}

func (cmd *ClusterShardsCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ClusterShardsCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]ClusterShard, n)

        for i := 0; i < n; i++ {
                m, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }

                for j := 0; j < m; j++ {
                        key, err := rd.ReadString()
                        if err != nil {
                                return err
                        }

                        switch key {
                        case "slots":
                                l, err := rd.ReadArrayLen()
                                if err != nil {
                                        return err
                                }
                                for k := 0; k < l; k += 2 {
                                        start, err := rd.ReadInt()
                                        if err != nil {
                                                return err
                                        }

                                        end, err := rd.ReadInt()
                                        if err != nil {
                                                return err
                                        }

                                        cmd.val[i].Slots = append(cmd.val[i].Slots, SlotRange{Start: start, End: end})
                                }
                        case "nodes":
                                nodesLen, err := rd.ReadArrayLen()
                                if err != nil {
                                        return err
                                }
                                cmd.val[i].Nodes = make([]Node, nodesLen)
                                for k := 0; k < nodesLen; k++ {
                                        nodeMapLen, err := rd.ReadMapLen()
                                        if err != nil {
                                                return err
                                        }

                                        for l := 0; l < nodeMapLen; l++ {
                                                nodeKey, err := rd.ReadString()
                                                if err != nil {
                                                        return err
                                                }

                                                switch nodeKey {
                                                case "id":
                                                        cmd.val[i].Nodes[k].ID, err = rd.ReadString()
                                                case "endpoint":
                                                        cmd.val[i].Nodes[k].Endpoint, err = rd.ReadString()
                                                case "ip":
                                                        cmd.val[i].Nodes[k].IP, err = rd.ReadString()
                                                case "hostname":
                                                        cmd.val[i].Nodes[k].Hostname, err = rd.ReadString()
                                                case "port":
                                                        cmd.val[i].Nodes[k].Port, err = rd.ReadInt()
                                                case "tls-port":
                                                        cmd.val[i].Nodes[k].TLSPort, err = rd.ReadInt()
                                                case "role":
                                                        cmd.val[i].Nodes[k].Role, err = rd.ReadString()
                                                case "replication-offset":
                                                        cmd.val[i].Nodes[k].ReplicationOffset, err = rd.ReadInt()
                                                case "health":
                                                        cmd.val[i].Nodes[k].Health, err = rd.ReadString()
                                                default:
                                                        return fmt.Errorf("redis: unexpected key %q in CLUSTER SHARDS node reply", nodeKey)
                                                }

                                                if err != nil {
                                                        return err
                                                }
                                        }
                                }
                        default:
                                return fmt.Errorf("redis: unexpected key %q in CLUSTER SHARDS reply", key)
                        }
                }
        }

        return nil
}

// -----------------------------------------

type RankScore struct {
        Rank  int64
        Score float64
}

type RankWithScoreCmd struct {
        baseCmd

        val RankScore
}

var _ Cmder = (*RankWithScoreCmd)(nil)

func NewRankWithScoreCmd(ctx context.Context, args ...interface{}) *RankWithScoreCmd {
        return &RankWithScoreCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *RankWithScoreCmd) SetVal(val RankScore) {
        cmd.val = val
}

func (cmd *RankWithScoreCmd) Val() RankScore {
        return cmd.val
}

func (cmd *RankWithScoreCmd) Result() (RankScore, error) {
        return cmd.val, cmd.err
}

func (cmd *RankWithScoreCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *RankWithScoreCmd) readReply(rd *proto.Reader) error {
        if err := rd.ReadFixedArrayLen(2); err != nil {
                return err
        }

        rank, err := rd.ReadInt()
        if err != nil {
                return err
        }

        score, err := rd.ReadFloat()
        if err != nil {
                return err
        }

        cmd.val = RankScore{Rank: rank, Score: score}

        return nil
}

// --------------------------------------------------------------------------------------------------

// ClientFlags is redis-server client flags, copy from redis/src/server.h (redis 7.0)
type ClientFlags uint64

const (
        ClientSlave            ClientFlags = 1 << 0  /* This client is a replica */
        ClientMaster           ClientFlags = 1 << 1  /* This client is a master */
        ClientMonitor          ClientFlags = 1 << 2  /* This client is a slave monitor, see MONITOR */
        ClientMulti            ClientFlags = 1 << 3  /* This client is in a MULTI context */
        ClientBlocked          ClientFlags = 1 << 4  /* The client is waiting in a blocking operation */
        ClientDirtyCAS         ClientFlags = 1 << 5  /* Watched keys modified. EXEC will fail. */
        ClientCloseAfterReply  ClientFlags = 1 << 6  /* Close after writing entire reply. */
        ClientUnBlocked        ClientFlags = 1 << 7  /* This client was unblocked and is stored in server.unblocked_clients */
        ClientScript           ClientFlags = 1 << 8  /* This is a non-connected client used by Lua */
        ClientAsking           ClientFlags = 1 << 9  /* Client issued the ASKING command */
        ClientCloseASAP        ClientFlags = 1 << 10 /* Close this client ASAP */
        ClientUnixSocket       ClientFlags = 1 << 11 /* Client connected via Unix domain socket */
        ClientDirtyExec        ClientFlags = 1 << 12 /* EXEC will fail for errors while queueing */
        ClientMasterForceReply ClientFlags = 1 << 13 /* Queue replies even if is master */
        ClientForceAOF         ClientFlags = 1 << 14 /* Force AOF propagation of current cmd. */
        ClientForceRepl        ClientFlags = 1 << 15 /* Force replication of current cmd. */
        ClientPrePSync         ClientFlags = 1 << 16 /* Instance don't understand PSYNC. */
        ClientReadOnly         ClientFlags = 1 << 17 /* Cluster client is in read-only state. */
        ClientPubSub           ClientFlags = 1 << 18 /* Client is in Pub/Sub mode. */
        ClientPreventAOFProp   ClientFlags = 1 << 19 /* Don't propagate to AOF. */
        ClientPreventReplProp  ClientFlags = 1 << 20 /* Don't propagate to slaves. */
        ClientPreventProp      ClientFlags = ClientPreventAOFProp | ClientPreventReplProp
        ClientPendingWrite     ClientFlags = 1 << 21 /* Client has output to send but a-write handler is yet not installed. */
        ClientReplyOff         ClientFlags = 1 << 22 /* Don't send replies to client. */
        ClientReplySkipNext    ClientFlags = 1 << 23 /* Set ClientREPLY_SKIP for next cmd */
        ClientReplySkip        ClientFlags = 1 << 24 /* Don't send just this reply. */
        ClientLuaDebug         ClientFlags = 1 << 25 /* Run EVAL in debug mode. */
        ClientLuaDebugSync     ClientFlags = 1 << 26 /* EVAL debugging without fork() */
        ClientModule           ClientFlags = 1 << 27 /* Non connected client used by some module. */
        ClientProtected        ClientFlags = 1 << 28 /* Client should not be freed for now. */
        ClientExecutingCommand ClientFlags = 1 << 29 /* Indicates that the client is currently in the process of handling
           a command. usually this will be marked only during call()
           however, blocked clients might have this flag kept until they
           will try to reprocess the command. */
        ClientPendingCommand      ClientFlags = 1 << 30 /* Indicates the client has a fully * parsed command ready for execution. */
        ClientTracking            ClientFlags = 1 << 31 /* Client enabled keys tracking in order to perform client side caching. */
        ClientTrackingBrokenRedir ClientFlags = 1 << 32 /* Target client is invalid. */
        ClientTrackingBCAST       ClientFlags = 1 << 33 /* Tracking in BCAST mode. */
        ClientTrackingOptIn       ClientFlags = 1 << 34 /* Tracking in opt-in mode. */
        ClientTrackingOptOut      ClientFlags = 1 << 35 /* Tracking in opt-out mode. */
        ClientTrackingCaching     ClientFlags = 1 << 36 /* CACHING yes/no was given, depending on optin/optout mode. */
        ClientTrackingNoLoop      ClientFlags = 1 << 37 /* Don't send invalidation messages about writes performed by myself.*/
        ClientInTimeoutTable      ClientFlags = 1 << 38 /* This client is in the timeout table. */
        ClientProtocolError       ClientFlags = 1 << 39 /* Protocol error chatting with it. */
        ClientCloseAfterCommand   ClientFlags = 1 << 40 /* Close after executing commands * and writing entire reply. */
        ClientDenyBlocking        ClientFlags = 1 << 41 /* Indicate that the client should not be blocked. currently, turned on inside MULTI, Lua, RM_Call, and AOF client */
        ClientReplRDBOnly         ClientFlags = 1 << 42 /* This client is a replica that only wants RDB without replication buffer. */
        ClientNoEvict             ClientFlags = 1 << 43 /* This client is protected against client memory eviction. */
        ClientAllowOOM            ClientFlags = 1 << 44 /* Client used by RM_Call is allowed to fully execute scripts even when in OOM */
        ClientNoTouch             ClientFlags = 1 << 45 /* This client will not touch LFU/LRU stats. */
        ClientPushing             ClientFlags = 1 << 46 /* This client is pushing notifications. */
)

// ClientInfo is redis-server ClientInfo, not go-redis *Client
type ClientInfo struct {
        ID                 int64         // redis version 2.8.12, a unique 64-bit client ID
        Addr               string        // address/port of the client
        LAddr              string        // address/port of local address client connected to (bind address)
        FD                 int64         // file descriptor corresponding to the socket
        Name               string        // the name set by the client with CLIENT SETNAME
        Age                time.Duration // total duration of the connection in seconds
        Idle               time.Duration // idle time of the connection in seconds
        Flags              ClientFlags   // client flags (see below)
        DB                 int           // current database ID
        Sub                int           // number of channel subscriptions
        PSub               int           // number of pattern matching subscriptions
        SSub               int           // redis version 7.0.3, number of shard channel subscriptions
        Multi              int           // number of commands in a MULTI/EXEC context
        Watch              int           // redis version 7.4 RC1, number of keys this client is currently watching.
        QueryBuf           int           // qbuf, query buffer length (0 means no query pending)
        QueryBufFree       int           // qbuf-free, free space of the query buffer (0 means the buffer is full)
        ArgvMem            int           // incomplete arguments for the next command (already extracted from query buffer)
        MultiMem           int           // redis version 7.0, memory is used up by buffered multi commands
        BufferSize         int           // rbs, usable size of buffer
        BufferPeak         int           // rbp, peak used size of buffer in last 5 sec interval
        OutputBufferLength int           // obl, output buffer length
        OutputListLength   int           // oll, output list length (replies are queued in this list when the buffer is full)
        OutputMemory       int           // omem, output buffer memory usage
        TotalMemory        int           // tot-mem, total memory consumed by this client in its various buffers
        TotalNetIn         int           // tot-net-in, total network input
        TotalNetOut        int           // tot-net-out, total network output
        TotalCmds          int           // tot-cmds, total number of commands processed
        IoThread           int           // io-thread id
        Events             string        // file descriptor events (see below)
        LastCmd            string        // cmd, last command played
        User               string        // the authenticated username of the client
        Redir              int64         // client id of current client tracking redirection
        Resp               int           // redis version 7.0, client RESP protocol version
        LibName            string        // redis version 7.2, client library name
        LibVer             string        // redis version 7.2, client library version
}

type ClientInfoCmd struct {
        baseCmd

        val *ClientInfo
}

var _ Cmder = (*ClientInfoCmd)(nil)

func NewClientInfoCmd(ctx context.Context, args ...interface{}) *ClientInfoCmd {
        return &ClientInfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ClientInfoCmd) SetVal(val *ClientInfo) {
        cmd.val = val
}

func (cmd *ClientInfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ClientInfoCmd) Val() *ClientInfo {
        return cmd.val
}

func (cmd *ClientInfoCmd) Result() (*ClientInfo, error) {
        return cmd.val, cmd.err
}

func (cmd *ClientInfoCmd) readReply(rd *proto.Reader) (err error) {
        txt, err := rd.ReadString()
        if err != nil {
                return err
        }

        // sds o = catClientInfoString(sdsempty(), c);
        // o = sdscatlen(o,"\n",1);
        // addReplyVerbatim(c,o,sdslen(o),"txt");
        // sdsfree(o);
        cmd.val, err = parseClientInfo(strings.TrimSpace(txt))
        return err
}

// fmt.Sscanf() cannot handle null values
func parseClientInfo(txt string) (info *ClientInfo, err error) {
        info = &ClientInfo{}
        for _, s := range strings.Split(txt, " ") {
                kv := strings.Split(s, "=")
                if len(kv) != 2 {
                        return nil, fmt.Errorf("redis: unexpected client info data (%s)", s)
                }
                key, val := kv[0], kv[1]

                switch key {
                case "id":
                        info.ID, err = strconv.ParseInt(val, 10, 64)
                case "addr":
                        info.Addr = val
                case "laddr":
                        info.LAddr = val
                case "fd":
                        info.FD, err = strconv.ParseInt(val, 10, 64)
                case "name":
                        info.Name = val
                case "age":
                        var age int
                        if age, err = strconv.Atoi(val); err == nil {
                                info.Age = time.Duration(age) * time.Second
                        }
                case "idle":
                        var idle int
                        if idle, err = strconv.Atoi(val); err == nil {
                                info.Idle = time.Duration(idle) * time.Second
                        }
                case "flags":
                        if val == "N" {
                                break
                        }

                        for i := 0; i < len(val); i++ {
                                switch val[i] {
                                case 'S':
                                        info.Flags |= ClientSlave
                                case 'O':
                                        info.Flags |= ClientSlave | ClientMonitor
                                case 'M':
                                        info.Flags |= ClientMaster
                                case 'P':
                                        info.Flags |= ClientPubSub
                                case 'x':
                                        info.Flags |= ClientMulti
                                case 'b':
                                        info.Flags |= ClientBlocked
                                case 't':
                                        info.Flags |= ClientTracking
                                case 'R':
                                        info.Flags |= ClientTrackingBrokenRedir
                                case 'B':
                                        info.Flags |= ClientTrackingBCAST
                                case 'd':
                                        info.Flags |= ClientDirtyCAS
                                case 'c':
                                        info.Flags |= ClientCloseAfterCommand
                                case 'u':
                                        info.Flags |= ClientUnBlocked
                                case 'A':
                                        info.Flags |= ClientCloseASAP
                                case 'U':
                                        info.Flags |= ClientUnixSocket
                                case 'r':
                                        info.Flags |= ClientReadOnly
                                case 'e':
                                        info.Flags |= ClientNoEvict
                                case 'T':
                                        info.Flags |= ClientNoTouch
                                default:
                                        return nil, fmt.Errorf("redis: unexpected client info flags(%s)", string(val[i]))
                                }
                        }
                case "db":
                        info.DB, err = strconv.Atoi(val)
                case "sub":
                        info.Sub, err = strconv.Atoi(val)
                case "psub":
                        info.PSub, err = strconv.Atoi(val)
                case "ssub":
                        info.SSub, err = strconv.Atoi(val)
                case "multi":
                        info.Multi, err = strconv.Atoi(val)
                case "watch":
                        info.Watch, err = strconv.Atoi(val)
                case "qbuf":
                        info.QueryBuf, err = strconv.Atoi(val)
                case "qbuf-free":
                        info.QueryBufFree, err = strconv.Atoi(val)
                case "argv-mem":
                        info.ArgvMem, err = strconv.Atoi(val)
                case "multi-mem":
                        info.MultiMem, err = strconv.Atoi(val)
                case "rbs":
                        info.BufferSize, err = strconv.Atoi(val)
                case "rbp":
                        info.BufferPeak, err = strconv.Atoi(val)
                case "obl":
                        info.OutputBufferLength, err = strconv.Atoi(val)
                case "oll":
                        info.OutputListLength, err = strconv.Atoi(val)
                case "omem":
                        info.OutputMemory, err = strconv.Atoi(val)
                case "tot-mem":
                        info.TotalMemory, err = strconv.Atoi(val)
                case "tot-net-in":
                        info.TotalNetIn, err = strconv.Atoi(val)
                case "tot-net-out":
                        info.TotalNetOut, err = strconv.Atoi(val)
                case "tot-cmds":
                        info.TotalCmds, err = strconv.Atoi(val)
                case "events":
                        info.Events = val
                case "cmd":
                        info.LastCmd = val
                case "user":
                        info.User = val
                case "redir":
                        info.Redir, err = strconv.ParseInt(val, 10, 64)
                case "resp":
                        info.Resp, err = strconv.Atoi(val)
                case "lib-name":
                        info.LibName = val
                case "lib-ver":
                        info.LibVer = val
                case "io-thread":
                        info.IoThread, err = strconv.Atoi(val)
                default:
                        return nil, fmt.Errorf("redis: unexpected client info key(%s)", key)
                }

                if err != nil {
                        return nil, err
                }
        }

        return info, nil
}

// -------------------------------------------

type ACLLogEntry struct {
        Count                int64
        Reason               string
        Context              string
        Object               string
        Username             string
        AgeSeconds           float64
        ClientInfo           *ClientInfo
        EntryID              int64
        TimestampCreated     int64
        TimestampLastUpdated int64
}

type ACLLogCmd struct {
        baseCmd

        val []*ACLLogEntry
}

var _ Cmder = (*ACLLogCmd)(nil)

func NewACLLogCmd(ctx context.Context, args ...interface{}) *ACLLogCmd {
        return &ACLLogCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ACLLogCmd) SetVal(val []*ACLLogEntry) {
        cmd.val = val
}

func (cmd *ACLLogCmd) Val() []*ACLLogEntry {
        return cmd.val
}

func (cmd *ACLLogCmd) Result() ([]*ACLLogEntry, error) {
        return cmd.val, cmd.err
}

func (cmd *ACLLogCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ACLLogCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }

        cmd.val = make([]*ACLLogEntry, n)
        for i := 0; i < n; i++ {
                cmd.val[i] = &ACLLogEntry{}
                entry := cmd.val[i]
                respLen, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }
                for j := 0; j < respLen; j++ {
                        key, err := rd.ReadString()
                        if err != nil {
                                return err
                        }

                        switch key {
                        case "count":
                                entry.Count, err = rd.ReadInt()
                        case "reason":
                                entry.Reason, err = rd.ReadString()
                        case "context":
                                entry.Context, err = rd.ReadString()
                        case "object":
                                entry.Object, err = rd.ReadString()
                        case "username":
                                entry.Username, err = rd.ReadString()
                        case "age-seconds":
                                entry.AgeSeconds, err = rd.ReadFloat()
                        case "client-info":
                                txt, err := rd.ReadString()
                                if err != nil {
                                        return err
                                }
                                entry.ClientInfo, err = parseClientInfo(strings.TrimSpace(txt))
                                if err != nil {
                                        return err
                                }
                        case "entry-id":
                                entry.EntryID, err = rd.ReadInt()
                        case "timestamp-created":
                                entry.TimestampCreated, err = rd.ReadInt()
                        case "timestamp-last-updated":
                                entry.TimestampLastUpdated, err = rd.ReadInt()
                        default:
                                return fmt.Errorf("redis: unexpected key %q in ACL LOG reply", key)
                        }

                        if err != nil {
                                return err
                        }
                }
        }

        return nil
}

// LibraryInfo holds the library info.
type LibraryInfo struct {
        LibName *string
        LibVer  *string
}

// WithLibraryName returns a valid LibraryInfo with library name only.
func WithLibraryName(libName string) LibraryInfo {
        return LibraryInfo{LibName: &libName}
}

// WithLibraryVersion returns a valid LibraryInfo with library version only.
func WithLibraryVersion(libVer string) LibraryInfo {
        return LibraryInfo{LibVer: &libVer}
}

// -------------------------------------------

type InfoCmd struct {
        baseCmd
        val map[string]map[string]string
}

var _ Cmder = (*InfoCmd)(nil)

func NewInfoCmd(ctx context.Context, args ...interface{}) *InfoCmd {
        return &InfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *InfoCmd) SetVal(val map[string]map[string]string) {
        cmd.val = val
}

func (cmd *InfoCmd) Val() map[string]map[string]string {
        return cmd.val
}

func (cmd *InfoCmd) Result() (map[string]map[string]string, error) {
        return cmd.val, cmd.err
}

func (cmd *InfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *InfoCmd) readReply(rd *proto.Reader) error {
        val, err := rd.ReadString()
        if err != nil {
                return err
        }

        section := ""
        scanner := bufio.NewScanner(strings.NewReader(val))
        for scanner.Scan() {
                line := scanner.Text()
                if strings.HasPrefix(line, "#") {
                        if cmd.val == nil {
                                cmd.val = make(map[string]map[string]string)
                        }
                        section = strings.TrimPrefix(line, "# ")
                        cmd.val[section] = make(map[string]string)
                } else if line != "" {
                        if section == "Modules" {
                                moduleRe := regexp.MustCompile(`module:name=(.+?),(.+)$`)
                                kv := moduleRe.FindStringSubmatch(line)
                                if len(kv) == 3 {
                                        cmd.val[section][kv[1]] = kv[2]
                                }
                        } else {
                                kv := strings.SplitN(line, ":", 2)
                                if len(kv) == 2 {
                                        cmd.val[section][kv[0]] = kv[1]
                                }
                        }
                }
        }

        return nil
}

func (cmd *InfoCmd) Item(section, key string) string {
        if cmd.val == nil {
                return ""
        } else if cmd.val[section] == nil {
                return ""
        } else {
                return cmd.val[section][key]
        }
}

type MonitorStatus int

const (
        monitorStatusIdle MonitorStatus = iota
        monitorStatusStart
        monitorStatusStop
)

type MonitorCmd struct {
        baseCmd
        ch     chan string
        status MonitorStatus
        mu     sync.Mutex
}

func newMonitorCmd(ctx context.Context, ch chan string) *MonitorCmd {
        return &MonitorCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: []interface{}{"monitor"},
                },
                ch:     ch,
                status: monitorStatusIdle,
                mu:     sync.Mutex{},
        }
}

func (cmd *MonitorCmd) String() string {
        return cmdString(cmd, nil)
}

func (cmd *MonitorCmd) readReply(rd *proto.Reader) error {
        ctx, cancel := context.WithCancel(cmd.ctx)
        go func(ctx context.Context) {
                for {
                        select {
                        case <-ctx.Done():
                                return
                        default:
                                err := cmd.readMonitor(rd, cancel)
                                if err != nil {
                                        cmd.err = err
                                        return
                                }
                        }
                }
        }(ctx)
        return nil
}

func (cmd *MonitorCmd) readMonitor(rd *proto.Reader, cancel context.CancelFunc) error {
        for {
                cmd.mu.Lock()
                st := cmd.status
                pk, _ := rd.Peek(1)
                cmd.mu.Unlock()
                if len(pk) != 0 && st == monitorStatusStart {
                        cmd.mu.Lock()
                        line, err := rd.ReadString()
                        cmd.mu.Unlock()
                        if err != nil {
                                return err
                        }
                        cmd.ch <- line
                }
                if st == monitorStatusStop {
                        cancel()
                        break
                }
        }
        return nil
}

func (cmd *MonitorCmd) Start() {
        cmd.mu.Lock()
        defer cmd.mu.Unlock()
        cmd.status = monitorStatusStart
}

func (cmd *MonitorCmd) Stop() {
        cmd.mu.Lock()
        defer cmd.mu.Unlock()
        cmd.status = monitorStatusStop
}

type VectorScoreSliceCmd struct {
        baseCmd

        val []VectorScore
}

var _ Cmder = (*VectorScoreSliceCmd)(nil)

func NewVectorInfoSliceCmd(ctx context.Context, args ...any) *VectorScoreSliceCmd {
        return &VectorScoreSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *VectorScoreSliceCmd) SetVal(val []VectorScore) {
        cmd.val = val
}

func (cmd *VectorScoreSliceCmd) Val() []VectorScore {
        return cmd.val
}

func (cmd *VectorScoreSliceCmd) Result() ([]VectorScore, error) {
        return cmd.val, cmd.err
}

func (cmd *VectorScoreSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *VectorScoreSliceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        cmd.val = make([]VectorScore, n)
        for i := 0; i < n; i++ {
                name, err := rd.ReadString()
                if err != nil {
                        return err
                }
                cmd.val[i].Name = name

                score, err := rd.ReadFloat()
                if err != nil {
                        return err
                }
                cmd.val[i].Score = score
        }
        return nil
}

package redis

import (
        "context"
        "encoding"
        "errors"
        "fmt"
        "io"
        "net"
        "reflect"
        "runtime"
        "strings"
        "time"

        "github.com/redis/go-redis/v9/internal"
)

// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
// otherwise you will receive an error: (error) ERR syntax error.
// For example:
//
//        rdb.Set(ctx, key, value, redis.KeepTTL)
const KeepTTL = -1

func usePrecise(dur time.Duration) bool {
        return dur < time.Second || dur%time.Second != 0
}

func formatMs(ctx context.Context, dur time.Duration) int64 {
        if dur > 0 && dur < time.Millisecond {
                internal.Logger.Printf(
                        ctx,
                        "specified duration is %s, but minimal supported value is %s - truncating to 1ms",
                        dur, time.Millisecond,
                )
                return 1
        }
        return int64(dur / time.Millisecond)
}

func formatSec(ctx context.Context, dur time.Duration) int64 {
        if dur > 0 && dur < time.Second {
                internal.Logger.Printf(
                        ctx,
                        "specified duration is %s, but minimal supported value is %s - truncating to 1s",
                        dur, time.Second,
                )
                return 1
        }
        return int64(dur / time.Second)
}

func appendArgs(dst, src []interface{}) []interface{} {
        if len(src) == 1 {
                return appendArg(dst, src[0])
        }

        dst = append(dst, src...)
        return dst
}

func appendArg(dst []interface{}, arg interface{}) []interface{} {
        switch arg := arg.(type) {
        case []string:
                for _, s := range arg {
                        dst = append(dst, s)
                }
                return dst
        case []interface{}:
                dst = append(dst, arg...)
                return dst
        case map[string]interface{}:
                for k, v := range arg {
                        dst = append(dst, k, v)
                }
                return dst
        case map[string]string:
                for k, v := range arg {
                        dst = append(dst, k, v)
                }
                return dst
        case time.Time, time.Duration, encoding.BinaryMarshaler, net.IP:
                return append(dst, arg)
        case nil:
                return dst
        default:
                // scan struct field
                v := reflect.ValueOf(arg)
                if v.Type().Kind() == reflect.Ptr {
                        if v.IsNil() {
                                // error: arg is not a valid object
                                return dst
                        }
                        v = v.Elem()
                }

                if v.Type().Kind() == reflect.Struct {
                        return appendStructField(dst, v)
                }

                return append(dst, arg)
        }
}

// appendStructField appends the field and value held by the structure v to dst, and returns the appended dst.
func appendStructField(dst []interface{}, v reflect.Value) []interface{} {
        typ := v.Type()
        for i := 0; i < typ.NumField(); i++ {
                tag := typ.Field(i).Tag.Get("redis")
                if tag == "" || tag == "-" {
                        continue
                }
                name, opt, _ := strings.Cut(tag, ",")
                if name == "" {
                        continue
                }

                field := v.Field(i)

                // miss field
                if omitEmpty(opt) && isEmptyValue(field) {
                        continue
                }

                if field.CanInterface() {
                        dst = append(dst, name, field.Interface())
                }
        }

        return dst
}

func omitEmpty(opt string) bool {
        for opt != "" {
                var name string
                name, opt, _ = strings.Cut(opt, ",")
                if name == "omitempty" {
                        return true
                }
        }
        return false
}

func isEmptyValue(v reflect.Value) bool {
        switch v.Kind() {
        case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
                return v.Len() == 0
        case reflect.Bool:
                return !v.Bool()
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                return v.Int() == 0
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
                return v.Uint() == 0
        case reflect.Float32, reflect.Float64:
                return v.Float() == 0
        case reflect.Interface, reflect.Pointer:
                return v.IsNil()
        case reflect.Struct:
                if v.Type() == reflect.TypeOf(time.Time{}) {
                        return v.IsZero()
                }
                // Only supports the struct time.Time,
                // subsequent iterations will follow the func Scan support decoder.
        }
        return false
}

type Cmdable interface {
        Pipeline() Pipeliner
        Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error)

        TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error)
        TxPipeline() Pipeliner

        Command(ctx context.Context) *CommandsInfoCmd
        CommandList(ctx context.Context, filter *FilterBy) *StringSliceCmd
        CommandGetKeys(ctx context.Context, commands ...interface{}) *StringSliceCmd
        CommandGetKeysAndFlags(ctx context.Context, commands ...interface{}) *KeyFlagsCmd
        ClientGetName(ctx context.Context) *StringCmd
        Echo(ctx context.Context, message interface{}) *StringCmd
        Ping(ctx context.Context) *StatusCmd
        Quit(ctx context.Context) *StatusCmd
        Unlink(ctx context.Context, keys ...string) *IntCmd

        BgRewriteAOF(ctx context.Context) *StatusCmd
        BgSave(ctx context.Context) *StatusCmd
        ClientKill(ctx context.Context, ipPort string) *StatusCmd
        ClientKillByFilter(ctx context.Context, keys ...string) *IntCmd
        ClientList(ctx context.Context) *StringCmd
        ClientInfo(ctx context.Context) *ClientInfoCmd
        ClientPause(ctx context.Context, dur time.Duration) *BoolCmd
        ClientUnpause(ctx context.Context) *BoolCmd
        ClientID(ctx context.Context) *IntCmd
        ClientUnblock(ctx context.Context, id int64) *IntCmd
        ClientUnblockWithError(ctx context.Context, id int64) *IntCmd
        ConfigGet(ctx context.Context, parameter string) *MapStringStringCmd
        ConfigResetStat(ctx context.Context) *StatusCmd
        ConfigSet(ctx context.Context, parameter, value string) *StatusCmd
        ConfigRewrite(ctx context.Context) *StatusCmd
        DBSize(ctx context.Context) *IntCmd
        FlushAll(ctx context.Context) *StatusCmd
        FlushAllAsync(ctx context.Context) *StatusCmd
        FlushDB(ctx context.Context) *StatusCmd
        FlushDBAsync(ctx context.Context) *StatusCmd
        Info(ctx context.Context, section ...string) *StringCmd
        LastSave(ctx context.Context) *IntCmd
        Save(ctx context.Context) *StatusCmd
        Shutdown(ctx context.Context) *StatusCmd
        ShutdownSave(ctx context.Context) *StatusCmd
        ShutdownNoSave(ctx context.Context) *StatusCmd
        SlaveOf(ctx context.Context, host, port string) *StatusCmd
        SlowLogGet(ctx context.Context, num int64) *SlowLogCmd
        Time(ctx context.Context) *TimeCmd
        DebugObject(ctx context.Context, key string) *StringCmd
        MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd

        ModuleLoadex(ctx context.Context, conf *ModuleLoadexConfig) *StringCmd

        ACLCmdable
        BitMapCmdable
        ClusterCmdable
        GenericCmdable
        GeoCmdable
        HashCmdable
        HyperLogLogCmdable
        ListCmdable
        ProbabilisticCmdable
        PubSubCmdable
        ScriptingFunctionsCmdable
        SearchCmdable
        SetCmdable
        SortedSetCmdable
        StringCmdable
        StreamCmdable
        TimeseriesCmdable
        JSONCmdable
        VectorSetCmdable
}

type StatefulCmdable interface {
        Cmdable
        Auth(ctx context.Context, password string) *StatusCmd
        AuthACL(ctx context.Context, username, password string) *StatusCmd
        Select(ctx context.Context, index int) *StatusCmd
        SwapDB(ctx context.Context, index1, index2 int) *StatusCmd
        ClientSetName(ctx context.Context, name string) *BoolCmd
        ClientSetInfo(ctx context.Context, info LibraryInfo) *StatusCmd
        Hello(ctx context.Context, ver int, username, password, clientName string) *MapStringInterfaceCmd
}

var (
        _ Cmdable = (*Client)(nil)
        _ Cmdable = (*Tx)(nil)
        _ Cmdable = (*Ring)(nil)
        _ Cmdable = (*ClusterClient)(nil)
)

type cmdable func(ctx context.Context, cmd Cmder) error

type statefulCmdable func(ctx context.Context, cmd Cmder) error

//------------------------------------------------------------------------------

func (c statefulCmdable) Auth(ctx context.Context, password string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "auth", password)
        _ = c(ctx, cmd)
        return cmd
}

// AuthACL Perform an AUTH command, using the given user and pass.
// Should be used to authenticate the current connection with one of the connections defined in the ACL list
// when connecting to a Redis 6.0 instance, or greater, that is using the Redis ACL system.
func (c statefulCmdable) AuthACL(ctx context.Context, username, password string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "auth", username, password)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Wait(ctx context.Context, numSlaves int, timeout time.Duration) *IntCmd {
        cmd := NewIntCmd(ctx, "wait", numSlaves, int(timeout/time.Millisecond))
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) WaitAOF(ctx context.Context, numLocal, numSlaves int, timeout time.Duration) *IntCmd {
        cmd := NewIntCmd(ctx, "waitAOF", numLocal, numSlaves, int(timeout/time.Millisecond))
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

func (c statefulCmdable) Select(ctx context.Context, index int) *StatusCmd {
        cmd := NewStatusCmd(ctx, "select", index)
        _ = c(ctx, cmd)
        return cmd
}

func (c statefulCmdable) SwapDB(ctx context.Context, index1, index2 int) *StatusCmd {
        cmd := NewStatusCmd(ctx, "swapdb", index1, index2)
        _ = c(ctx, cmd)
        return cmd
}

// ClientSetName assigns a name to the connection.
func (c statefulCmdable) ClientSetName(ctx context.Context, name string) *BoolCmd {
        cmd := NewBoolCmd(ctx, "client", "setname", name)
        _ = c(ctx, cmd)
        return cmd
}

// ClientSetInfo sends a CLIENT SETINFO command with the provided info.
func (c statefulCmdable) ClientSetInfo(ctx context.Context, info LibraryInfo) *StatusCmd {
        err := info.Validate()
        if err != nil {
                panic(err.Error())
        }

        var cmd *StatusCmd
        if info.LibName != nil {
                libName := fmt.Sprintf("go-redis(%s,%s)", *info.LibName, internal.ReplaceSpaces(runtime.Version()))
                cmd = NewStatusCmd(ctx, "client", "setinfo", "LIB-NAME", libName)
        } else {
                cmd = NewStatusCmd(ctx, "client", "setinfo", "LIB-VER", *info.LibVer)
        }

        _ = c(ctx, cmd)
        return cmd
}

// Validate checks if only one field in the struct is non-nil.
func (info LibraryInfo) Validate() error {
        if info.LibName != nil && info.LibVer != nil {
                return errors.New("both LibName and LibVer cannot be set at the same time")
        }
        if info.LibName == nil && info.LibVer == nil {
                return errors.New("at least one of LibName and LibVer should be set")
        }
        return nil
}

// Hello sets the resp protocol used.
func (c statefulCmdable) Hello(ctx context.Context,
        ver int, username, password, clientName string,
) *MapStringInterfaceCmd {
        args := make([]interface{}, 0, 7)
        args = append(args, "hello", ver)
        if password != "" {
                if username != "" {
                        args = append(args, "auth", username, password)
                } else {
                        args = append(args, "auth", "default", password)
                }
        }
        if clientName != "" {
                args = append(args, "setname", clientName)
        }
        cmd := NewMapStringInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

//------------------------------------------------------------------------------

func (c cmdable) Command(ctx context.Context) *CommandsInfoCmd {
        cmd := NewCommandsInfoCmd(ctx, "command")
        _ = c(ctx, cmd)
        return cmd
}

// FilterBy is used for the `CommandList` command parameter.
type FilterBy struct {
        Module  string
        ACLCat  string
        Pattern string
}

func (c cmdable) CommandList(ctx context.Context, filter *FilterBy) *StringSliceCmd {
        args := make([]interface{}, 0, 5)
        args = append(args, "command", "list")
        if filter != nil {
                if filter.Module != "" {
                        args = append(args, "filterby", "module", filter.Module)
                } else if filter.ACLCat != "" {
                        args = append(args, "filterby", "aclcat", filter.ACLCat)
                } else if filter.Pattern != "" {
                        args = append(args, "filterby", "pattern", filter.Pattern)
                }
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) CommandGetKeys(ctx context.Context, commands ...interface{}) *StringSliceCmd {
        args := make([]interface{}, 2+len(commands))
        args[0] = "command"
        args[1] = "getkeys"
        copy(args[2:], commands)
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) CommandGetKeysAndFlags(ctx context.Context, commands ...interface{}) *KeyFlagsCmd {
        args := make([]interface{}, 2+len(commands))
        args[0] = "command"
        args[1] = "getkeysandflags"
        copy(args[2:], commands)
        cmd := NewKeyFlagsCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// ClientGetName returns the name of the connection.
func (c cmdable) ClientGetName(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "client", "getname")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Echo(ctx context.Context, message interface{}) *StringCmd {
        cmd := NewStringCmd(ctx, "echo", message)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Ping(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "ping")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Do(ctx context.Context, args ...interface{}) *Cmd {
        cmd := NewCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Quit(_ context.Context) *StatusCmd {
        panic("not implemented")
}

//------------------------------------------------------------------------------

func (c cmdable) BgRewriteAOF(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "bgrewriteaof")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) BgSave(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "bgsave")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClientKill(ctx context.Context, ipPort string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "client", "kill", ipPort)
        _ = c(ctx, cmd)
        return cmd
}

// ClientKillByFilter is new style syntax, while the ClientKill is old
//
//        CLIENT KILL <option> [value] ... <option> [value]
func (c cmdable) ClientKillByFilter(ctx context.Context, keys ...string) *IntCmd {
        args := make([]interface{}, 2+len(keys))
        args[0] = "client"
        args[1] = "kill"
        for i, key := range keys {
                args[2+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClientList(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "client", "list")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClientPause(ctx context.Context, dur time.Duration) *BoolCmd {
        cmd := NewBoolCmd(ctx, "client", "pause", formatMs(ctx, dur))
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClientUnpause(ctx context.Context) *BoolCmd {
        cmd := NewBoolCmd(ctx, "client", "unpause")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClientID(ctx context.Context) *IntCmd {
        cmd := NewIntCmd(ctx, "client", "id")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClientUnblock(ctx context.Context, id int64) *IntCmd {
        cmd := NewIntCmd(ctx, "client", "unblock", id)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClientUnblockWithError(ctx context.Context, id int64) *IntCmd {
        cmd := NewIntCmd(ctx, "client", "unblock", id, "error")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ClientInfo(ctx context.Context) *ClientInfoCmd {
        cmd := NewClientInfoCmd(ctx, "client", "info")
        _ = c(ctx, cmd)
        return cmd
}

// ------------------------------------------------------------------------------------------------

func (c cmdable) ConfigGet(ctx context.Context, parameter string) *MapStringStringCmd {
        cmd := NewMapStringStringCmd(ctx, "config", "get", parameter)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ConfigResetStat(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "config", "resetstat")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ConfigSet(ctx context.Context, parameter, value string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "config", "set", parameter, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ConfigRewrite(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "config", "rewrite")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) DBSize(ctx context.Context) *IntCmd {
        cmd := NewIntCmd(ctx, "dbsize")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FlushAll(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "flushall")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FlushAllAsync(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "flushall", "async")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FlushDB(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "flushdb")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FlushDBAsync(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "flushdb", "async")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Info(ctx context.Context, sections ...string) *StringCmd {
        args := make([]interface{}, 1+len(sections))
        args[0] = "info"
        for i, section := range sections {
                args[i+1] = section
        }
        cmd := NewStringCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) InfoMap(ctx context.Context, sections ...string) *InfoCmd {
        args := make([]interface{}, 1+len(sections))
        args[0] = "info"
        for i, section := range sections {
                args[i+1] = section
        }
        cmd := NewInfoCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LastSave(ctx context.Context) *IntCmd {
        cmd := NewIntCmd(ctx, "lastsave")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Save(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "save")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) shutdown(ctx context.Context, modifier string) *StatusCmd {
        var args []interface{}
        if modifier == "" {
                args = []interface{}{"shutdown"}
        } else {
                args = []interface{}{"shutdown", modifier}
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        if err := cmd.Err(); err != nil {
                if err == io.EOF {
                        // Server quit as expected.
                        cmd.err = nil
                }
        } else {
                // Server did not quit. String reply contains the reason.
                cmd.err = errors.New(cmd.val)
                cmd.val = ""
        }
        return cmd
}

func (c cmdable) Shutdown(ctx context.Context) *StatusCmd {
        return c.shutdown(ctx, "")
}

func (c cmdable) ShutdownSave(ctx context.Context) *StatusCmd {
        return c.shutdown(ctx, "save")
}

func (c cmdable) ShutdownNoSave(ctx context.Context) *StatusCmd {
        return c.shutdown(ctx, "nosave")
}

func (c cmdable) SlaveOf(ctx context.Context, host, port string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "slaveof", host, port)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SlowLogGet(ctx context.Context, num int64) *SlowLogCmd {
        cmd := NewSlowLogCmd(context.Background(), "slowlog", "get", num)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Sync(_ context.Context) {
        panic("not implemented")
}

func (c cmdable) Time(ctx context.Context) *TimeCmd {
        cmd := NewTimeCmd(ctx, "time")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) DebugObject(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "debug", "object", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd {
        args := []interface{}{"memory", "usage", key}
        if len(samples) > 0 {
                if len(samples) != 1 {
                        panic("MemoryUsage expects single sample count")
                }
                args = append(args, "SAMPLES", samples[0])
        }
        cmd := NewIntCmd(ctx, args...)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

//------------------------------------------------------------------------------

// ModuleLoadexConfig struct is used to specify the arguments for the MODULE LOADEX command of redis.
// `MODULE LOADEX path [CONFIG name value [CONFIG name value ...]] [ARGS args [args ...]]`
type ModuleLoadexConfig struct {
        Path string
        Conf map[string]interface{}
        Args []interface{}
}

func (c *ModuleLoadexConfig) toArgs() []interface{} {
        args := make([]interface{}, 3, 3+len(c.Conf)*3+len(c.Args)*2)
        args[0] = "MODULE"
        args[1] = "LOADEX"
        args[2] = c.Path
        for k, v := range c.Conf {
                args = append(args, "CONFIG", k, v)
        }
        for _, arg := range c.Args {
                args = append(args, "ARGS", arg)
        }
        return args
}

// ModuleLoadex Redis `MODULE LOADEX path [CONFIG name value [CONFIG name value ...]] [ARGS args [args ...]]` command.
func (c cmdable) ModuleLoadex(ctx context.Context, conf *ModuleLoadexConfig) *StringCmd {
        cmd := NewStringCmd(ctx, conf.toArgs()...)
        _ = c(ctx, cmd)
        return cmd
}

/*
Monitor - represents a Redis MONITOR command, allowing the user to capture
and process all commands sent to a Redis server. This mimics the behavior of
MONITOR in the redis-cli.

Notes:
- Using MONITOR blocks the connection to the server for itself. It needs a dedicated connection
- The user should create a channel of type string
- This runs concurrently in the background. Trigger via the Start and Stop functions
See further: Redis MONITOR command: https://redis.io/commands/monitor
*/
func (c cmdable) Monitor(ctx context.Context, ch chan string) *MonitorCmd {
        cmd := newMonitorCmd(ctx, ch)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "errors"
        "io"
        "net"
        "strings"

        "github.com/redis/go-redis/v9/internal"
        "github.com/redis/go-redis/v9/internal/pool"
        "github.com/redis/go-redis/v9/internal/proto"
)

// ErrClosed performs any operation on the closed client will return this error.
var ErrClosed = pool.ErrClosed

// ErrPoolExhausted is returned from a pool connection method
// when the maximum number of database connections in the pool has been reached.
var ErrPoolExhausted = pool.ErrPoolExhausted

// ErrPoolTimeout timed out waiting to get a connection from the connection pool.
var ErrPoolTimeout = pool.ErrPoolTimeout

// ErrCrossSlot is returned when keys are used in the same Redis command and
// the keys are not in the same hash slot. This error is returned by Redis
// Cluster and will be returned by the client when TxPipeline or TxPipelined
// is used on a ClusterClient with keys in different slots.
var ErrCrossSlot = proto.RedisError("CROSSSLOT Keys in request don't hash to the same slot")

// HasErrorPrefix checks if the err is a Redis error and the message contains a prefix.
func HasErrorPrefix(err error, prefix string) bool {
        var rErr Error
        if !errors.As(err, &rErr) {
                return false
        }
        msg := rErr.Error()
        msg = strings.TrimPrefix(msg, "ERR ") // KVRocks adds such prefix
        return strings.HasPrefix(msg, prefix)
}

type Error interface {
        error

        // RedisError is a no-op function but
        // serves to distinguish types that are Redis
        // errors from ordinary errors: a type is a
        // Redis error if it has a RedisError method.
        RedisError()
}

var _ Error = proto.RedisError("")

func isContextError(err error) bool {
        switch err {
        case context.Canceled, context.DeadlineExceeded:
                return true
        default:
                return false
        }
}

func shouldRetry(err error, retryTimeout bool) bool {
        switch err {
        case io.EOF, io.ErrUnexpectedEOF:
                return true
        case nil, context.Canceled, context.DeadlineExceeded:
                return false
        case pool.ErrPoolTimeout:
                // connection pool timeout, increase retries. #3289
                return true
        }

        if v, ok := err.(timeoutError); ok {
                if v.Timeout() {
                        return retryTimeout
                }
                return true
        }

        s := err.Error()
        if s == "ERR max number of clients reached" {
                return true
        }
        if strings.HasPrefix(s, "LOADING ") {
                return true
        }
        if strings.HasPrefix(s, "READONLY ") {
                return true
        }
        if strings.HasPrefix(s, "MASTERDOWN ") {
                return true
        }
        if strings.HasPrefix(s, "CLUSTERDOWN ") {
                return true
        }
        if strings.HasPrefix(s, "TRYAGAIN ") {
                return true
        }

        return false
}

func isRedisError(err error) bool {
        _, ok := err.(proto.RedisError)
        return ok
}

func isBadConn(err error, allowTimeout bool, addr string) bool {
        switch err {
        case nil:
                return false
        case context.Canceled, context.DeadlineExceeded:
                return true
        }

        if isRedisError(err) {
                switch {
                case isReadOnlyError(err):
                        // Close connections in read only state in case domain addr is used
                        // and domain resolves to a different Redis Server. See #790.
                        return true
                case isMovedSameConnAddr(err, addr):
                        // Close connections when we are asked to move to the same addr
                        // of the connection. Force a DNS resolution when all connections
                        // of the pool are recycled
                        return true
                default:
                        return false
                }
        }

        if allowTimeout {
                if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                        return false
                }
        }

        return true
}

func isMovedError(err error) (moved bool, ask bool, addr string) {
        if !isRedisError(err) {
                return
        }

        s := err.Error()
        switch {
        case strings.HasPrefix(s, "MOVED "):
                moved = true
        case strings.HasPrefix(s, "ASK "):
                ask = true
        default:
                return
        }

        ind := strings.LastIndex(s, " ")
        if ind == -1 {
                return false, false, ""
        }

        addr = s[ind+1:]
        addr = internal.GetAddr(addr)
        return
}

func isLoadingError(err error) bool {
        return strings.HasPrefix(err.Error(), "LOADING ")
}

func isReadOnlyError(err error) bool {
        return strings.HasPrefix(err.Error(), "READONLY ")
}

func isMovedSameConnAddr(err error, addr string) bool {
        redisError := err.Error()
        if !strings.HasPrefix(redisError, "MOVED ") {
                return false
        }
        return strings.HasSuffix(redisError, " "+addr)
}

//------------------------------------------------------------------------------

type timeoutError interface {
        Timeout() bool
}

//go:build gofuzz
// +build gofuzz

package fuzz

import (
        "context"
        "time"

        "github.com/redis/go-redis/v9"
)

var (
        ctx = context.Background()
        rdb *redis.Client
)

func init() {
        rdb = redis.NewClient(&redis.Options{
                Addr:         ":6379",
                DialTimeout:  10 * time.Second,
                ReadTimeout:  10 * time.Second,
                WriteTimeout: 10 * time.Second,
                PoolSize:     10,
                PoolTimeout:  10 * time.Second,
        })
}

func Fuzz(data []byte) int {
        arrayLen := len(data)
        if arrayLen < 4 {
                return -1
        }
        maxIter := int(uint(data[0]))
        for i := 0; i < maxIter && i < arrayLen; i++ {
                n := i % arrayLen
                if n == 0 {
                        _ = rdb.Set(ctx, string(data[i:]), string(data[i:]), 0).Err()
                } else if n == 1 {
                        _, _ = rdb.Get(ctx, string(data[i:])).Result()
                } else if n == 2 {
                        _, _ = rdb.Incr(ctx, string(data[i:])).Result()
                } else if n == 3 {
                        var cursor uint64
                        _, _, _ = rdb.Scan(ctx, cursor, string(data[i:]), 10).Result()
                }
        }
        return 1
}

package redis

import (
        "context"
        "time"

        "github.com/redis/go-redis/v9/internal/hashtag"
)

type GenericCmdable interface {
        Del(ctx context.Context, keys ...string) *IntCmd
        Dump(ctx context.Context, key string) *StringCmd
        Exists(ctx context.Context, keys ...string) *IntCmd
        Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd
        ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
        ExpireTime(ctx context.Context, key string) *DurationCmd
        ExpireNX(ctx context.Context, key string, expiration time.Duration) *BoolCmd
        ExpireXX(ctx context.Context, key string, expiration time.Duration) *BoolCmd
        ExpireGT(ctx context.Context, key string, expiration time.Duration) *BoolCmd
        ExpireLT(ctx context.Context, key string, expiration time.Duration) *BoolCmd
        Keys(ctx context.Context, pattern string) *StringSliceCmd
        Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd
        Move(ctx context.Context, key string, db int) *BoolCmd
        ObjectFreq(ctx context.Context, key string) *IntCmd
        ObjectRefCount(ctx context.Context, key string) *IntCmd
        ObjectEncoding(ctx context.Context, key string) *StringCmd
        ObjectIdleTime(ctx context.Context, key string) *DurationCmd
        Persist(ctx context.Context, key string) *BoolCmd
        PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd
        PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
        PExpireTime(ctx context.Context, key string) *DurationCmd
        PTTL(ctx context.Context, key string) *DurationCmd
        RandomKey(ctx context.Context) *StringCmd
        Rename(ctx context.Context, key, newkey string) *StatusCmd
        RenameNX(ctx context.Context, key, newkey string) *BoolCmd
        Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd
        RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd
        Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd
        SortRO(ctx context.Context, key string, sort *Sort) *StringSliceCmd
        SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd
        SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd
        Touch(ctx context.Context, keys ...string) *IntCmd
        TTL(ctx context.Context, key string) *DurationCmd
        Type(ctx context.Context, key string) *StatusCmd
        Copy(ctx context.Context, sourceKey string, destKey string, db int, replace bool) *IntCmd

        Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd
        ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *ScanCmd
}

func (c cmdable) Del(ctx context.Context, keys ...string) *IntCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "del"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Unlink(ctx context.Context, keys ...string) *IntCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "unlink"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Dump(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "dump", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Exists(ctx context.Context, keys ...string) *IntCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "exists"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
        return c.expire(ctx, key, expiration, "")
}

func (c cmdable) ExpireNX(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
        return c.expire(ctx, key, expiration, "NX")
}

func (c cmdable) ExpireXX(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
        return c.expire(ctx, key, expiration, "XX")
}

func (c cmdable) ExpireGT(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
        return c.expire(ctx, key, expiration, "GT")
}

func (c cmdable) ExpireLT(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
        return c.expire(ctx, key, expiration, "LT")
}

func (c cmdable) expire(
        ctx context.Context, key string, expiration time.Duration, mode string,
) *BoolCmd {
        args := make([]interface{}, 3, 4)
        args[0] = "expire"
        args[1] = key
        args[2] = formatSec(ctx, expiration)
        if mode != "" {
                args = append(args, mode)
        }

        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
        cmd := NewBoolCmd(ctx, "expireat", key, tm.Unix())
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ExpireTime(ctx context.Context, key string) *DurationCmd {
        cmd := NewDurationCmd(ctx, time.Second, "expiretime", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Keys(ctx context.Context, pattern string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "keys", pattern)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd {
        cmd := NewStatusCmd(
                ctx,
                "migrate",
                host,
                port,
                key,
                db,
                formatMs(ctx, timeout),
        )
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Move(ctx context.Context, key string, db int) *BoolCmd {
        cmd := NewBoolCmd(ctx, "move", key, db)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ObjectFreq(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "object", "freq", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ObjectRefCount(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "object", "refcount", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ObjectEncoding(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "object", "encoding", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ObjectIdleTime(ctx context.Context, key string) *DurationCmd {
        cmd := NewDurationCmd(ctx, time.Second, "object", "idletime", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Persist(ctx context.Context, key string) *BoolCmd {
        cmd := NewBoolCmd(ctx, "persist", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
        cmd := NewBoolCmd(ctx, "pexpire", key, formatMs(ctx, expiration))
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
        cmd := NewBoolCmd(
                ctx,
                "pexpireat",
                key,
                tm.UnixNano()/int64(time.Millisecond),
        )
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PExpireTime(ctx context.Context, key string) *DurationCmd {
        cmd := NewDurationCmd(ctx, time.Millisecond, "pexpiretime", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PTTL(ctx context.Context, key string) *DurationCmd {
        cmd := NewDurationCmd(ctx, time.Millisecond, "pttl", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) RandomKey(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "randomkey")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Rename(ctx context.Context, key, newkey string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "rename", key, newkey)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) RenameNX(ctx context.Context, key, newkey string) *BoolCmd {
        cmd := NewBoolCmd(ctx, "renamenx", key, newkey)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {
        cmd := NewStatusCmd(
                ctx,
                "restore",
                key,
                formatMs(ctx, ttl),
                value,
        )
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {
        cmd := NewStatusCmd(
                ctx,
                "restore",
                key,
                formatMs(ctx, ttl),
                value,
                "replace",
        )
        _ = c(ctx, cmd)
        return cmd
}

type Sort struct {
        By            string
        Offset, Count int64
        Get           []string
        Order         string
        Alpha         bool
}

func (sort *Sort) args(command, key string) []interface{} {
        args := []interface{}{command, key}

        if sort.By != "" {
                args = append(args, "by", sort.By)
        }
        if sort.Offset != 0 || sort.Count != 0 {
                args = append(args, "limit", sort.Offset, sort.Count)
        }
        for _, get := range sort.Get {
                args = append(args, "get", get)
        }
        if sort.Order != "" {
                args = append(args, sort.Order)
        }
        if sort.Alpha {
                args = append(args, "alpha")
        }
        return args
}

func (c cmdable) SortRO(ctx context.Context, key string, sort *Sort) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, sort.args("sort_ro", key)...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, sort.args("sort", key)...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd {
        args := sort.args("sort", key)
        if store != "" {
                args = append(args, "store", store)
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd {
        cmd := NewSliceCmd(ctx, sort.args("sort", key)...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Touch(ctx context.Context, keys ...string) *IntCmd {
        args := make([]interface{}, len(keys)+1)
        args[0] = "touch"
        for i, key := range keys {
                args[i+1] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) TTL(ctx context.Context, key string) *DurationCmd {
        cmd := NewDurationCmd(ctx, time.Second, "ttl", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Type(ctx context.Context, key string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "type", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *IntCmd {
        args := []interface{}{"copy", sourceKey, destKey, "DB", db}
        if replace {
                args = append(args, "REPLACE")
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

//------------------------------------------------------------------------------

func (c cmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd {
        args := []interface{}{"scan", cursor}
        if match != "" {
                args = append(args, "match", match)
        }
        if count > 0 {
                args = append(args, "count", count)
        }
        cmd := NewScanCmd(ctx, c, args...)
        if hashtag.Present(match) {
                cmd.SetFirstKeyPos(3)
        }
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *ScanCmd {
        args := []interface{}{"scan", cursor}
        if match != "" {
                args = append(args, "match", match)
        }
        if count > 0 {
                args = append(args, "count", count)
        }
        if keyType != "" {
                args = append(args, "type", keyType)
        }
        cmd := NewScanCmd(ctx, c, args...)
        if hashtag.Present(match) {
                cmd.SetFirstKeyPos(3)
        }
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "errors"
)

type GeoCmdable interface {
        GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd
        GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd
        GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
        GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *IntCmd
        GeoRadiusByMember(ctx context.Context, key, member string, query *GeoRadiusQuery) *GeoLocationCmd
        GeoRadiusByMemberStore(ctx context.Context, key, member string, query *GeoRadiusQuery) *IntCmd
        GeoSearch(ctx context.Context, key string, q *GeoSearchQuery) *StringSliceCmd
        GeoSearchLocation(ctx context.Context, key string, q *GeoSearchLocationQuery) *GeoSearchLocationCmd
        GeoSearchStore(ctx context.Context, key, store string, q *GeoSearchStoreQuery) *IntCmd
        GeoDist(ctx context.Context, key string, member1, member2, unit string) *FloatCmd
        GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd
}

func (c cmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd {
        args := make([]interface{}, 2+3*len(geoLocation))
        args[0] = "geoadd"
        args[1] = key
        for i, eachLoc := range geoLocation {
                args[2+3*i] = eachLoc.Longitude
                args[2+3*i+1] = eachLoc.Latitude
                args[2+3*i+2] = eachLoc.Name
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// GeoRadius is a read-only GEORADIUS_RO command.
func (c cmdable) GeoRadius(
        ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery,
) *GeoLocationCmd {
        cmd := NewGeoLocationCmd(ctx, query, "georadius_ro", key, longitude, latitude)
        if query.Store != "" || query.StoreDist != "" {
                cmd.SetErr(errors.New("GeoRadius does not support Store or StoreDist"))
                return cmd
        }
        _ = c(ctx, cmd)
        return cmd
}

// GeoRadiusStore is a writing GEORADIUS command.
func (c cmdable) GeoRadiusStore(
        ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery,
) *IntCmd {
        args := geoLocationArgs(query, "georadius", key, longitude, latitude)
        cmd := NewIntCmd(ctx, args...)
        if query.Store == "" && query.StoreDist == "" {
                cmd.SetErr(errors.New("GeoRadiusStore requires Store or StoreDist"))
                return cmd
        }
        _ = c(ctx, cmd)
        return cmd
}

// GeoRadiusByMember is a read-only GEORADIUSBYMEMBER_RO command.
func (c cmdable) GeoRadiusByMember(
        ctx context.Context, key, member string, query *GeoRadiusQuery,
) *GeoLocationCmd {
        cmd := NewGeoLocationCmd(ctx, query, "georadiusbymember_ro", key, member)
        if query.Store != "" || query.StoreDist != "" {
                cmd.SetErr(errors.New("GeoRadiusByMember does not support Store or StoreDist"))
                return cmd
        }
        _ = c(ctx, cmd)
        return cmd
}

// GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.
func (c cmdable) GeoRadiusByMemberStore(
        ctx context.Context, key, member string, query *GeoRadiusQuery,
) *IntCmd {
        args := geoLocationArgs(query, "georadiusbymember", key, member)
        cmd := NewIntCmd(ctx, args...)
        if query.Store == "" && query.StoreDist == "" {
                cmd.SetErr(errors.New("GeoRadiusByMemberStore requires Store or StoreDist"))
                return cmd
        }
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) GeoSearch(ctx context.Context, key string, q *GeoSearchQuery) *StringSliceCmd {
        args := make([]interface{}, 0, 13)
        args = append(args, "geosearch", key)
        args = geoSearchArgs(q, args)
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) GeoSearchLocation(
        ctx context.Context, key string, q *GeoSearchLocationQuery,
) *GeoSearchLocationCmd {
        args := make([]interface{}, 0, 16)
        args = append(args, "geosearch", key)
        args = geoSearchLocationArgs(q, args)
        cmd := NewGeoSearchLocationCmd(ctx, q, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) GeoSearchStore(ctx context.Context, key, store string, q *GeoSearchStoreQuery) *IntCmd {
        args := make([]interface{}, 0, 15)
        args = append(args, "geosearchstore", store, key)
        args = geoSearchArgs(&q.GeoSearchQuery, args)
        if q.StoreDist {
                args = append(args, "storedist")
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) GeoDist(
        ctx context.Context, key string, member1, member2, unit string,
) *FloatCmd {
        if unit == "" {
                unit = "km"
        }
        cmd := NewFloatCmd(ctx, "geodist", key, member1, member2, unit)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd {
        args := make([]interface{}, 2+len(members))
        args[0] = "geohash"
        args[1] = key
        for i, member := range members {
                args[2+i] = member
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd {
        args := make([]interface{}, 2+len(members))
        args[0] = "geopos"
        args[1] = key
        for i, member := range members {
                args[2+i] = member
        }
        cmd := NewGeoPosCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "time"

        "github.com/redis/go-redis/v9/internal/hashtag"
)

type HashCmdable interface {
        HDel(ctx context.Context, key string, fields ...string) *IntCmd
        HExists(ctx context.Context, key, field string) *BoolCmd
        HGet(ctx context.Context, key, field string) *StringCmd
        HGetAll(ctx context.Context, key string) *MapStringStringCmd
        HGetDel(ctx context.Context, key string, fields ...string) *StringSliceCmd
        HGetEX(ctx context.Context, key string, fields ...string) *StringSliceCmd
        HGetEXWithArgs(ctx context.Context, key string, options *HGetEXOptions, fields ...string) *StringSliceCmd
        HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd
        HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd
        HKeys(ctx context.Context, key string) *StringSliceCmd
        HLen(ctx context.Context, key string) *IntCmd
        HMGet(ctx context.Context, key string, fields ...string) *SliceCmd
        HSet(ctx context.Context, key string, values ...interface{}) *IntCmd
        HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd
        HSetEX(ctx context.Context, key string, fieldsAndValues ...string) *IntCmd
        HSetEXWithArgs(ctx context.Context, key string, options *HSetEXOptions, fieldsAndValues ...string) *IntCmd
        HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd
        HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
        HScanNoValues(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
        HVals(ctx context.Context, key string) *StringSliceCmd
        HRandField(ctx context.Context, key string, count int) *StringSliceCmd
        HRandFieldWithValues(ctx context.Context, key string, count int) *KeyValueSliceCmd
        HStrLen(ctx context.Context, key, field string) *IntCmd
        HExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *IntSliceCmd
        HExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs HExpireArgs, fields ...string) *IntSliceCmd
        HPExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *IntSliceCmd
        HPExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs HExpireArgs, fields ...string) *IntSliceCmd
        HExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *IntSliceCmd
        HExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs HExpireArgs, fields ...string) *IntSliceCmd
        HPExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *IntSliceCmd
        HPExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs HExpireArgs, fields ...string) *IntSliceCmd
        HPersist(ctx context.Context, key string, fields ...string) *IntSliceCmd
        HExpireTime(ctx context.Context, key string, fields ...string) *IntSliceCmd
        HPExpireTime(ctx context.Context, key string, fields ...string) *IntSliceCmd
        HTTL(ctx context.Context, key string, fields ...string) *IntSliceCmd
        HPTTL(ctx context.Context, key string, fields ...string) *IntSliceCmd
}

func (c cmdable) HDel(ctx context.Context, key string, fields ...string) *IntCmd {
        args := make([]interface{}, 2+len(fields))
        args[0] = "hdel"
        args[1] = key
        for i, field := range fields {
                args[2+i] = field
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HExists(ctx context.Context, key, field string) *BoolCmd {
        cmd := NewBoolCmd(ctx, "hexists", key, field)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HGet(ctx context.Context, key, field string) *StringCmd {
        cmd := NewStringCmd(ctx, "hget", key, field)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HGetAll(ctx context.Context, key string) *MapStringStringCmd {
        cmd := NewMapStringStringCmd(ctx, "hgetall", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd {
        cmd := NewIntCmd(ctx, "hincrby", key, field, incr)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd {
        cmd := NewFloatCmd(ctx, "hincrbyfloat", key, field, incr)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HKeys(ctx context.Context, key string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "hkeys", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HLen(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "hlen", key)
        _ = c(ctx, cmd)
        return cmd
}

// HMGet returns the values for the specified fields in the hash stored at key.
// It returns an interface{} to distinguish between empty string and nil value.
func (c cmdable) HMGet(ctx context.Context, key string, fields ...string) *SliceCmd {
        args := make([]interface{}, 2+len(fields))
        args[0] = "hmget"
        args[1] = key
        for i, field := range fields {
                args[2+i] = field
        }
        cmd := NewSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HSet accepts values in following formats:
//
//   - HSet("myhash", "key1", "value1", "key2", "value2")
//
//   - HSet("myhash", []string{"key1", "value1", "key2", "value2"})
//
//   - HSet("myhash", map[string]interface{}{"key1": "value1", "key2": "value2"})
//
//     Playing struct With "redis" tag.
//     type MyHash struct { Key1 string `redis:"key1"`; Key2 int `redis:"key2"` }
//
//   - HSet("myhash", MyHash{"value1", "value2"}) Warn: redis-server >= 4.0
//
//     For struct, can be a structure pointer type, we only parse the field whose tag is redis.
//     if you don't want the field to be read, you can use the `redis:"-"` flag to ignore it,
//     or you don't need to set the redis tag.
//     For the type of structure field, we only support simple data types:
//     string, int/uint(8,16,32,64), float(32,64), time.Time(to RFC3339Nano), time.Duration(to Nanoseconds ),
//     if you are other more complex or custom data types, please implement the encoding.BinaryMarshaler interface.
//
// Note that in older versions of Redis server(redis-server < 4.0), HSet only supports a single key-value pair.
// redis-docs: https://redis.io/commands/hset (Starting with Redis version 4.0.0: Accepts multiple field and value arguments.)
// If you are using a Struct type and the number of fields is greater than one,
// you will receive an error similar to "ERR wrong number of arguments", you can use HMSet as a substitute.
func (c cmdable) HSet(ctx context.Context, key string, values ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(values))
        args[0] = "hset"
        args[1] = key
        args = appendArgs(args, values)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HMSet is a deprecated version of HSet left for compatibility with Redis 3.
func (c cmdable) HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd {
        args := make([]interface{}, 2, 2+len(values))
        args[0] = "hmset"
        args[1] = key
        args = appendArgs(args, values)
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd {
        cmd := NewBoolCmd(ctx, "hsetnx", key, field, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HVals(ctx context.Context, key string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "hvals", key)
        _ = c(ctx, cmd)
        return cmd
}

// HRandField redis-server version >= 6.2.0.
func (c cmdable) HRandField(ctx context.Context, key string, count int) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "hrandfield", key, count)
        _ = c(ctx, cmd)
        return cmd
}

// HRandFieldWithValues redis-server version >= 6.2.0.
func (c cmdable) HRandFieldWithValues(ctx context.Context, key string, count int) *KeyValueSliceCmd {
        cmd := NewKeyValueSliceCmd(ctx, "hrandfield", key, count, "withvalues")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
        args := []interface{}{"hscan", key, cursor}
        if match != "" {
                args = append(args, "match", match)
        }
        if count > 0 {
                args = append(args, "count", count)
        }
        cmd := NewScanCmd(ctx, c, args...)
        if hashtag.Present(match) {
                cmd.SetFirstKeyPos(4)
        }
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HStrLen(ctx context.Context, key, field string) *IntCmd {
        cmd := NewIntCmd(ctx, "hstrlen", key, field)
        _ = c(ctx, cmd)
        return cmd
}
func (c cmdable) HScanNoValues(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
        args := []interface{}{"hscan", key, cursor}
        if match != "" {
                args = append(args, "match", match)
        }
        if count > 0 {
                args = append(args, "count", count)
        }
        args = append(args, "novalues")
        cmd := NewScanCmd(ctx, c, args...)
        if hashtag.Present(match) {
                cmd.SetFirstKeyPos(4)
        }
        _ = c(ctx, cmd)
        return cmd
}

type HExpireArgs struct {
        NX bool
        XX bool
        GT bool
        LT bool
}

// HExpire - Sets the expiration time for specified fields in a hash in seconds.
// The command constructs an argument list starting with "HEXPIRE", followed by the key, duration, any conditional flags, and the specified fields.
// Available since Redis 7.4 CE.
// For more information refer to [HEXPIRE Documentation].
//
// [HEXPIRE Documentation]: https://redis.io/commands/hexpire/
func (c cmdable) HExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *IntSliceCmd {
        args := []interface{}{"HEXPIRE", key, formatSec(ctx, expiration), "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HExpireWithArgs - Sets the expiration time for specified fields in a hash in seconds.
// It requires a key, an expiration duration, a struct with boolean flags for conditional expiration settings (NX, XX, GT, LT), and a list of fields.
// The command constructs an argument list starting with "HEXPIRE", followed by the key, duration, any conditional flags, and the specified fields.
// Available since Redis 7.4 CE.
// For more information refer to [HEXPIRE Documentation].
//
// [HEXPIRE Documentation]: https://redis.io/commands/hexpire/
func (c cmdable) HExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs HExpireArgs, fields ...string) *IntSliceCmd {
        args := []interface{}{"HEXPIRE", key, formatSec(ctx, expiration)}

        // only if one argument is true, we can add it to the args
        // if more than one argument is true, it will cause an error
        if expirationArgs.NX {
                args = append(args, "NX")
        } else if expirationArgs.XX {
                args = append(args, "XX")
        } else if expirationArgs.GT {
                args = append(args, "GT")
        } else if expirationArgs.LT {
                args = append(args, "LT")
        }

        args = append(args, "FIELDS", len(fields))

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HPExpire - Sets the expiration time for specified fields in a hash in milliseconds.
// Similar to HExpire, it accepts a key, an expiration duration in milliseconds, a struct with expiration condition flags, and a list of fields.
// The command modifies the standard time.Duration to milliseconds for the Redis command.
// Available since Redis 7.4 CE.
// For more information refer to [HPEXPIRE Documentation].
//
// [HPEXPIRE Documentation]: https://redis.io/commands/hpexpire/
func (c cmdable) HPExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *IntSliceCmd {
        args := []interface{}{"HPEXPIRE", key, formatMs(ctx, expiration), "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HPExpireWithArgs - Sets the expiration time for specified fields in a hash in milliseconds.
// It requires a key, an expiration duration, a struct with boolean flags for conditional expiration settings (NX, XX, GT, LT), and a list of fields.
// The command constructs an argument list starting with "HPEXPIRE", followed by the key, duration, any conditional flags, and the specified fields.
// Available since Redis 7.4 CE.
// For more information refer to [HPEXPIRE Documentation].
//
// [HPEXPIRE Documentation]: https://redis.io/commands/hpexpire/
func (c cmdable) HPExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs HExpireArgs, fields ...string) *IntSliceCmd {
        args := []interface{}{"HPEXPIRE", key, formatMs(ctx, expiration)}

        // only if one argument is true, we can add it to the args
        // if more than one argument is true, it will cause an error
        if expirationArgs.NX {
                args = append(args, "NX")
        } else if expirationArgs.XX {
                args = append(args, "XX")
        } else if expirationArgs.GT {
                args = append(args, "GT")
        } else if expirationArgs.LT {
                args = append(args, "LT")
        }

        args = append(args, "FIELDS", len(fields))

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HExpireAt - Sets the expiration time for specified fields in a hash to a UNIX timestamp in seconds.
// Takes a key, a UNIX timestamp, a struct of conditional flags, and a list of fields.
// The command sets absolute expiration times based on the UNIX timestamp provided.
// Available since Redis 7.4 CE.
// For more information refer to [HExpireAt Documentation].
//
// [HExpireAt Documentation]: https://redis.io/commands/hexpireat/
func (c cmdable) HExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *IntSliceCmd {

        args := []interface{}{"HEXPIREAT", key, tm.Unix(), "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs HExpireArgs, fields ...string) *IntSliceCmd {
        args := []interface{}{"HEXPIREAT", key, tm.Unix()}

        // only if one argument is true, we can add it to the args
        // if more than one argument is true, it will cause an error
        if expirationArgs.NX {
                args = append(args, "NX")
        } else if expirationArgs.XX {
                args = append(args, "XX")
        } else if expirationArgs.GT {
                args = append(args, "GT")
        } else if expirationArgs.LT {
                args = append(args, "LT")
        }

        args = append(args, "FIELDS", len(fields))

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HPExpireAt - Sets the expiration time for specified fields in a hash to a UNIX timestamp in milliseconds.
// Similar to HExpireAt but for timestamps in milliseconds. It accepts the same parameters and adjusts the UNIX time to milliseconds.
// Available since Redis 7.4 CE.
// For more information refer to [HExpireAt Documentation].
//
// [HExpireAt Documentation]: https://redis.io/commands/hexpireat/
func (c cmdable) HPExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *IntSliceCmd {
        args := []interface{}{"HPEXPIREAT", key, tm.UnixNano() / int64(time.Millisecond), "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HPExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs HExpireArgs, fields ...string) *IntSliceCmd {
        args := []interface{}{"HPEXPIREAT", key, tm.UnixNano() / int64(time.Millisecond)}

        // only if one argument is true, we can add it to the args
        // if more than one argument is true, it will cause an error
        if expirationArgs.NX {
                args = append(args, "NX")
        } else if expirationArgs.XX {
                args = append(args, "XX")
        } else if expirationArgs.GT {
                args = append(args, "GT")
        } else if expirationArgs.LT {
                args = append(args, "LT")
        }

        args = append(args, "FIELDS", len(fields))

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HPersist - Removes the expiration time from specified fields in a hash.
// Accepts a key and the fields themselves.
// This command ensures that each field specified will have its expiration removed if present.
// Available since Redis 7.4 CE.
// For more information refer to [HPersist Documentation].
//
// [HPersist Documentation]: https://redis.io/commands/hpersist/
func (c cmdable) HPersist(ctx context.Context, key string, fields ...string) *IntSliceCmd {
        args := []interface{}{"HPERSIST", key, "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HExpireTime - Retrieves the expiration time for specified fields in a hash as a UNIX timestamp in seconds.
// Requires a key and the fields themselves to fetch their expiration timestamps.
// This command returns the expiration times for each field or error/status codes for each field as specified.
// Available since Redis 7.4 CE.
// For more information refer to [HExpireTime Documentation].
//
// [HExpireTime Documentation]: https://redis.io/commands/hexpiretime/
// For more information - https://redis.io/commands/hexpiretime/
func (c cmdable) HExpireTime(ctx context.Context, key string, fields ...string) *IntSliceCmd {
        args := []interface{}{"HEXPIRETIME", key, "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HPExpireTime - Retrieves the expiration time for specified fields in a hash as a UNIX timestamp in milliseconds.
// Similar to HExpireTime, adjusted for timestamps in milliseconds. It requires the same parameters.
// Provides the expiration timestamp for each field in milliseconds.
// Available since Redis 7.4 CE.
// For more information refer to [HExpireTime Documentation].
//
// [HExpireTime Documentation]: https://redis.io/commands/hexpiretime/
// For more information - https://redis.io/commands/hexpiretime/
func (c cmdable) HPExpireTime(ctx context.Context, key string, fields ...string) *IntSliceCmd {
        args := []interface{}{"HPEXPIRETIME", key, "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HTTL - Retrieves the remaining time to live for specified fields in a hash in seconds.
// Requires a key and the fields themselves. It returns the TTL for each specified field.
// This command fetches the TTL in seconds for each field or returns error/status codes as appropriate.
// Available since Redis 7.4 CE.
// For more information refer to [HTTL Documentation].
//
// [HTTL Documentation]: https://redis.io/commands/httl/
func (c cmdable) HTTL(ctx context.Context, key string, fields ...string) *IntSliceCmd {
        args := []interface{}{"HTTL", key, "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HPTTL - Retrieves the remaining time to live for specified fields in a hash in milliseconds.
// Similar to HTTL, but returns the TTL in milliseconds. It requires a key and the specified fields.
// This command provides the TTL in milliseconds for each field or returns error/status codes as needed.
// Available since Redis 7.4 CE.
// For more information refer to [HPTTL Documentation].
//
// [HPTTL Documentation]: https://redis.io/commands/hpttl/
// For more information - https://redis.io/commands/hpttl/
func (c cmdable) HPTTL(ctx context.Context, key string, fields ...string) *IntSliceCmd {
        args := []interface{}{"HPTTL", key, "FIELDS", len(fields)}

        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HGetDel(ctx context.Context, key string, fields ...string) *StringSliceCmd {
        args := []interface{}{"HGETDEL", key, "FIELDS", len(fields)}
        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HGetEX(ctx context.Context, key string, fields ...string) *StringSliceCmd {
        args := []interface{}{"HGETEX", key, "FIELDS", len(fields)}
        for _, field := range fields {
                args = append(args, field)
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// HGetEXExpirationType represents an expiration option for the HGETEX command.
type HGetEXExpirationType string

const (
        HGetEXExpirationEX      HGetEXExpirationType = "EX"
        HGetEXExpirationPX      HGetEXExpirationType = "PX"
        HGetEXExpirationEXAT    HGetEXExpirationType = "EXAT"
        HGetEXExpirationPXAT    HGetEXExpirationType = "PXAT"
        HGetEXExpirationPERSIST HGetEXExpirationType = "PERSIST"
)

type HGetEXOptions struct {
        ExpirationType HGetEXExpirationType
        ExpirationVal  int64
}

func (c cmdable) HGetEXWithArgs(ctx context.Context, key string, options *HGetEXOptions, fields ...string) *StringSliceCmd {
        args := []interface{}{"HGETEX", key}
        if options.ExpirationType != "" {
                args = append(args, string(options.ExpirationType))
                if options.ExpirationType != HGetEXExpirationPERSIST {
                        args = append(args, options.ExpirationVal)
                }
        }

        args = append(args, "FIELDS", len(fields))
        for _, field := range fields {
                args = append(args, field)
        }

        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type HSetEXCondition string

const (
        HSetEXFNX HSetEXCondition = "FNX" // Only set the fields if none of them already exist.
        HSetEXFXX HSetEXCondition = "FXX" // Only set the fields if all already exist.
)

type HSetEXExpirationType string

const (
        HSetEXExpirationEX      HSetEXExpirationType = "EX"
        HSetEXExpirationPX      HSetEXExpirationType = "PX"
        HSetEXExpirationEXAT    HSetEXExpirationType = "EXAT"
        HSetEXExpirationPXAT    HSetEXExpirationType = "PXAT"
        HSetEXExpirationKEEPTTL HSetEXExpirationType = "KEEPTTL"
)

type HSetEXOptions struct {
        Condition      HSetEXCondition
        ExpirationType HSetEXExpirationType
        ExpirationVal  int64
}

func (c cmdable) HSetEX(ctx context.Context, key string, fieldsAndValues ...string) *IntCmd {
        args := []interface{}{"HSETEX", key, "FIELDS", len(fieldsAndValues) / 2}
        for _, field := range fieldsAndValues {
                args = append(args, field)
        }

        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) HSetEXWithArgs(ctx context.Context, key string, options *HSetEXOptions, fieldsAndValues ...string) *IntCmd {
        args := []interface{}{"HSETEX", key}
        if options.Condition != "" {
                args = append(args, string(options.Condition))
        }
        if options.ExpirationType != "" {
                args = append(args, string(options.ExpirationType))
                if options.ExpirationType != HSetEXExpirationKEEPTTL {
                        args = append(args, options.ExpirationVal)
                }
        }
        args = append(args, "FIELDS", len(fieldsAndValues)/2)
        for _, field := range fieldsAndValues {
                args = append(args, field)
        }

        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import "context"

type HyperLogLogCmdable interface {
        PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd
        PFCount(ctx context.Context, keys ...string) *IntCmd
        PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd
}

func (c cmdable) PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(els))
        args[0] = "pfadd"
        args[1] = key
        args = appendArgs(args, els)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PFCount(ctx context.Context, keys ...string) *IntCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "pfcount"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd {
        args := make([]interface{}, 2+len(keys))
        args[0] = "pfmerge"
        args[1] = dest
        for i, key := range keys {
                args[2+i] = key
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package internal

import (
        "fmt"
        "strconv"
        "time"

        "github.com/redis/go-redis/v9/internal/util"
)

func AppendArg(b []byte, v interface{}) []byte {
        switch v := v.(type) {
        case nil:
                return append(b, "<nil>"...)
        case string:
                return appendUTF8String(b, util.StringToBytes(v))
        case []byte:
                return appendUTF8String(b, v)
        case int:
                return strconv.AppendInt(b, int64(v), 10)
        case int8:
                return strconv.AppendInt(b, int64(v), 10)
        case int16:
                return strconv.AppendInt(b, int64(v), 10)
        case int32:
                return strconv.AppendInt(b, int64(v), 10)
        case int64:
                return strconv.AppendInt(b, v, 10)
        case uint:
                return strconv.AppendUint(b, uint64(v), 10)
        case uint8:
                return strconv.AppendUint(b, uint64(v), 10)
        case uint16:
                return strconv.AppendUint(b, uint64(v), 10)
        case uint32:
                return strconv.AppendUint(b, uint64(v), 10)
        case uint64:
                return strconv.AppendUint(b, v, 10)
        case float32:
                return strconv.AppendFloat(b, float64(v), 'f', -1, 64)
        case float64:
                return strconv.AppendFloat(b, v, 'f', -1, 64)
        case bool:
                if v {
                        return append(b, "true"...)
                }
                return append(b, "false"...)
        case time.Time:
                return v.AppendFormat(b, time.RFC3339Nano)
        default:
                return append(b, fmt.Sprint(v)...)
        }
}

func appendUTF8String(dst []byte, src []byte) []byte {
        dst = append(dst, src...)
        return dst
}

package hashtag

import (
        "strings"

        "github.com/redis/go-redis/v9/internal/rand"
)

const slotNumber = 16384

// CRC16 implementation according to CCITT standards.
// Copyright 2001-2010 Georges Menie (www.menie.org)
// Copyright 2013 The Go Authors. All rights reserved.
// http://redis.io/topics/cluster-spec#appendix-a-crc16-reference-implementation-in-ansi-c
var crc16tab = [256]uint16{
        0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
        0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
        0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
        0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
        0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
        0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
        0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
        0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
        0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
        0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
        0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
        0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
        0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
        0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
        0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
        0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
        0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
        0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
        0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
        0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
        0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
        0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
        0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
        0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
        0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
        0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
        0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
        0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
        0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
        0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
        0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
        0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
}

func Key(key string) string {
        if s := strings.IndexByte(key, '{'); s > -1 {
                if e := strings.IndexByte(key[s+1:], '}'); e > 0 {
                        return key[s+1 : s+e+1]
                }
        }
        return key
}

func Present(key string) bool {
        if key == "" {
                return false
        }
        if s := strings.IndexByte(key, '{'); s > -1 {
                if e := strings.IndexByte(key[s+1:], '}'); e > 0 {
                        return true
                }
        }
        return false
}

func RandomSlot() int {
        return rand.Intn(slotNumber)
}

// Slot returns a consistent slot number between 0 and 16383
// for any given string key.
func Slot(key string) int {
        if key == "" {
                return RandomSlot()
        }
        key = Key(key)
        return int(crc16sum(key)) % slotNumber
}

func crc16sum(key string) (crc uint16) {
        for i := 0; i < len(key); i++ {
                crc = (crc << 8) ^ crc16tab[(byte(crc>>8)^key[i])&0x00ff]
        }
        return
}

package hscan

import (
        "errors"
        "fmt"
        "reflect"
        "strconv"
)

// decoderFunc represents decoding functions for default built-in types.
type decoderFunc func(reflect.Value, string) error

// Scanner is the interface implemented by themselves,
// which will override the decoding behavior of decoderFunc.
type Scanner interface {
        ScanRedis(s string) error
}

var (
        // List of built-in decoders indexed by their numeric constant values (eg: reflect.Bool = 1).
        decoders = []decoderFunc{
                reflect.Bool:          decodeBool,
                reflect.Int:           decodeInt,
                reflect.Int8:          decodeInt8,
                reflect.Int16:         decodeInt16,
                reflect.Int32:         decodeInt32,
                reflect.Int64:         decodeInt64,
                reflect.Uint:          decodeUint,
                reflect.Uint8:         decodeUint8,
                reflect.Uint16:        decodeUint16,
                reflect.Uint32:        decodeUint32,
                reflect.Uint64:        decodeUint64,
                reflect.Float32:       decodeFloat32,
                reflect.Float64:       decodeFloat64,
                reflect.Complex64:     decodeUnsupported,
                reflect.Complex128:    decodeUnsupported,
                reflect.Array:         decodeUnsupported,
                reflect.Chan:          decodeUnsupported,
                reflect.Func:          decodeUnsupported,
                reflect.Interface:     decodeUnsupported,
                reflect.Map:           decodeUnsupported,
                reflect.Ptr:           decodeUnsupported,
                reflect.Slice:         decodeSlice,
                reflect.String:        decodeString,
                reflect.Struct:        decodeUnsupported,
                reflect.UnsafePointer: decodeUnsupported,
        }

        // Global map of struct field specs that is populated once for every new
        // struct type that is scanned. This caches the field types and the corresponding
        // decoder functions to avoid iterating through struct fields on subsequent scans.
        globalStructMap = newStructMap()
)

func Struct(dst interface{}) (StructValue, error) {
        v := reflect.ValueOf(dst)

        // The destination to scan into should be a struct pointer.
        if v.Kind() != reflect.Ptr || v.IsNil() {
                return StructValue{}, fmt.Errorf("redis.Scan(non-pointer %T)", dst)
        }

        v = v.Elem()
        if v.Kind() != reflect.Struct {
                return StructValue{}, fmt.Errorf("redis.Scan(non-struct %T)", dst)
        }

        return StructValue{
                spec:  globalStructMap.get(v.Type()),
                value: v,
        }, nil
}

// Scan scans the results from a key-value Redis map result set to a destination struct.
// The Redis keys are matched to the struct's field with the `redis` tag.
func Scan(dst interface{}, keys []interface{}, vals []interface{}) error {
        if len(keys) != len(vals) {
                return errors.New("args should have the same number of keys and vals")
        }

        strct, err := Struct(dst)
        if err != nil {
                return err
        }

        // Iterate through the (key, value) sequence.
        for i := 0; i < len(vals); i++ {
                key, ok := keys[i].(string)
                if !ok {
                        continue
                }

                val, ok := vals[i].(string)
                if !ok {
                        continue
                }

                if err := strct.Scan(key, val); err != nil {
                        return err
                }
        }

        return nil
}

func decodeBool(f reflect.Value, s string) error {
        b, err := strconv.ParseBool(s)
        if err != nil {
                return err
        }
        f.SetBool(b)
        return nil
}

func decodeInt8(f reflect.Value, s string) error {
        return decodeNumber(f, s, 8)
}

func decodeInt16(f reflect.Value, s string) error {
        return decodeNumber(f, s, 16)
}

func decodeInt32(f reflect.Value, s string) error {
        return decodeNumber(f, s, 32)
}

func decodeInt64(f reflect.Value, s string) error {
        return decodeNumber(f, s, 64)
}

func decodeInt(f reflect.Value, s string) error {
        return decodeNumber(f, s, 0)
}

func decodeNumber(f reflect.Value, s string, bitSize int) error {
        v, err := strconv.ParseInt(s, 10, bitSize)
        if err != nil {
                return err
        }
        f.SetInt(v)
        return nil
}

func decodeUint8(f reflect.Value, s string) error {
        return decodeUnsignedNumber(f, s, 8)
}

func decodeUint16(f reflect.Value, s string) error {
        return decodeUnsignedNumber(f, s, 16)
}

func decodeUint32(f reflect.Value, s string) error {
        return decodeUnsignedNumber(f, s, 32)
}

func decodeUint64(f reflect.Value, s string) error {
        return decodeUnsignedNumber(f, s, 64)
}

func decodeUint(f reflect.Value, s string) error {
        return decodeUnsignedNumber(f, s, 0)
}

func decodeUnsignedNumber(f reflect.Value, s string, bitSize int) error {
        v, err := strconv.ParseUint(s, 10, bitSize)
        if err != nil {
                return err
        }
        f.SetUint(v)
        return nil
}

func decodeFloat32(f reflect.Value, s string) error {
        v, err := strconv.ParseFloat(s, 32)
        if err != nil {
                return err
        }
        f.SetFloat(v)
        return nil
}

// although the default is float64, but we better define it.
func decodeFloat64(f reflect.Value, s string) error {
        v, err := strconv.ParseFloat(s, 64)
        if err != nil {
                return err
        }
        f.SetFloat(v)
        return nil
}

func decodeString(f reflect.Value, s string) error {
        f.SetString(s)
        return nil
}

func decodeSlice(f reflect.Value, s string) error {
        // []byte slice ([]uint8).
        if f.Type().Elem().Kind() == reflect.Uint8 {
                f.SetBytes([]byte(s))
        }
        return nil
}

func decodeUnsupported(v reflect.Value, s string) error {
        return fmt.Errorf("redis.Scan(unsupported %s)", v.Type())
}

package hscan

import (
        "encoding"
        "fmt"
        "reflect"
        "strings"
        "sync"

        "github.com/redis/go-redis/v9/internal/util"
)

// structMap contains the map of struct fields for target structs
// indexed by the struct type.
type structMap struct {
        m sync.Map
}

func newStructMap() *structMap {
        return new(structMap)
}

func (s *structMap) get(t reflect.Type) *structSpec {
        if v, ok := s.m.Load(t); ok {
                return v.(*structSpec)
        }

        spec := newStructSpec(t, "redis")
        s.m.Store(t, spec)
        return spec
}

//------------------------------------------------------------------------------

// structSpec contains the list of all fields in a target struct.
type structSpec struct {
        m map[string]*structField
}

func (s *structSpec) set(tag string, sf *structField) {
        s.m[tag] = sf
}

func newStructSpec(t reflect.Type, fieldTag string) *structSpec {
        numField := t.NumField()
        out := &structSpec{
                m: make(map[string]*structField, numField),
        }

        for i := 0; i < numField; i++ {
                f := t.Field(i)

                tag := f.Tag.Get(fieldTag)
                if tag == "" || tag == "-" {
                        continue
                }

                tag = strings.Split(tag, ",")[0]
                if tag == "" {
                        continue
                }

                // Use the built-in decoder.
                kind := f.Type.Kind()
                if kind == reflect.Pointer {
                        kind = f.Type.Elem().Kind()
                }
                out.set(tag, &structField{index: i, fn: decoders[kind]})
        }

        return out
}

//------------------------------------------------------------------------------

// structField represents a single field in a target struct.
type structField struct {
        index int
        fn    decoderFunc
}

//------------------------------------------------------------------------------

type StructValue struct {
        spec  *structSpec
        value reflect.Value
}

func (s StructValue) Scan(key string, value string) error {
        field, ok := s.spec.m[key]
        if !ok {
                return nil
        }

        v := s.value.Field(field.index)
        isPtr := v.Kind() == reflect.Ptr

        if isPtr && v.IsNil() {
                v.Set(reflect.New(v.Type().Elem()))
        }
        if !isPtr && v.Type().Name() != "" && v.CanAddr() {
                v = v.Addr()
                isPtr = true
        }

        if isPtr && v.Type().NumMethod() > 0 && v.CanInterface() {
                switch scan := v.Interface().(type) {
                case Scanner:
                        return scan.ScanRedis(value)
                case encoding.TextUnmarshaler:
                        return scan.UnmarshalText(util.StringToBytes(value))
                }
        }

        if isPtr {
                v = v.Elem()
        }

        if err := field.fn(v, value); err != nil {
                t := s.value.Type()
                return fmt.Errorf("cannot scan redis.result %s into struct field %s.%s of type %s, error-%s",
                        value, t.Name(), t.Field(field.index).Name, t.Field(field.index).Type, err.Error())
        }
        return nil
}

package internal

import (
        "time"

        "github.com/redis/go-redis/v9/internal/rand"
)

func RetryBackoff(retry int, minBackoff, maxBackoff time.Duration) time.Duration {
        if retry < 0 {
                panic("not reached")
        }
        if minBackoff == 0 {
                return 0
        }

        d := minBackoff << uint(retry)
        if d < minBackoff {
                return maxBackoff
        }

        d = minBackoff + time.Duration(rand.Int63n(int64(d)))

        if d > maxBackoff || d < minBackoff {
                d = maxBackoff
        }

        return d
}

package internal

import (
        "context"
        "fmt"
        "log"
        "os"
)

type Logging interface {
        Printf(ctx context.Context, format string, v ...interface{})
}

type logger struct {
        log *log.Logger
}

func (l *logger) Printf(ctx context.Context, format string, v ...interface{}) {
        _ = l.log.Output(2, fmt.Sprintf(format, v...))
}

// Logger calls Output to print to the stderr.
// Arguments are handled in the manner of fmt.Print.
var Logger Logging = &logger{
        log: log.New(os.Stderr, "redis: ", log.LstdFlags|log.Lshortfile),
}

/*
Copyright 2014 The Camlistore Authors

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package internal

import (
        "sync"
        "sync/atomic"
)

// A Once will perform a successful action exactly once.
//
// Unlike a sync.Once, this Once's func returns an error
// and is re-armed on failure.
type Once struct {
        m    sync.Mutex
        done uint32
}

// Do calls the function f if and only if Do has not been invoked
// without error for this instance of Once.  In other words, given
//
//        var once Once
//
// if once.Do(f) is called multiple times, only the first call will
// invoke f, even if f has a different value in each invocation unless
// f returns an error.  A new instance of Once is required for each
// function to execute.
//
// Do is intended for initialization that must be run exactly once.  Since f
// is niladic, it may be necessary to use a function literal to capture the
// arguments to a function to be invoked by Do:
//
//        err := config.once.Do(func() error { return config.init(filename) })
func (o *Once) Do(f func() error) error {
        if atomic.LoadUint32(&o.done) == 1 {
                return nil
        }
        // Slow-path.
        o.m.Lock()
        defer o.m.Unlock()
        var err error
        if o.done == 0 {
                err = f()
                if err == nil {
                        atomic.StoreUint32(&o.done, 1)
                }
        }
        return err
}

package pool

import (
        "bufio"
        "context"
        "net"
        "sync/atomic"
        "time"

        "github.com/redis/go-redis/v9/internal/proto"
)

var noDeadline = time.Time{}

type Conn struct {
        usedAt  int64 // atomic
        netConn net.Conn

        rd *proto.Reader
        bw *bufio.Writer
        wr *proto.Writer

        Inited    bool
        pooled    bool
        createdAt time.Time

        onClose func() error
}

func NewConn(netConn net.Conn) *Conn {
        cn := &Conn{
                netConn:   netConn,
                createdAt: time.Now(),
        }
        cn.rd = proto.NewReader(netConn)
        cn.bw = bufio.NewWriter(netConn)
        cn.wr = proto.NewWriter(cn.bw)
        cn.SetUsedAt(time.Now())
        return cn
}

func (cn *Conn) UsedAt() time.Time {
        unix := atomic.LoadInt64(&cn.usedAt)
        return time.Unix(unix, 0)
}

func (cn *Conn) SetUsedAt(tm time.Time) {
        atomic.StoreInt64(&cn.usedAt, tm.Unix())
}

func (cn *Conn) SetOnClose(fn func() error) {
        cn.onClose = fn
}

func (cn *Conn) SetNetConn(netConn net.Conn) {
        cn.netConn = netConn
        cn.rd.Reset(netConn)
        cn.bw.Reset(netConn)
}

func (cn *Conn) Write(b []byte) (int, error) {
        return cn.netConn.Write(b)
}

func (cn *Conn) RemoteAddr() net.Addr {
        if cn.netConn != nil {
                return cn.netConn.RemoteAddr()
        }
        return nil
}

func (cn *Conn) WithReader(
        ctx context.Context, timeout time.Duration, fn func(rd *proto.Reader) error,
) error {
        if timeout >= 0 {
                if err := cn.netConn.SetReadDeadline(cn.deadline(ctx, timeout)); err != nil {
                        return err
                }
        }
        return fn(cn.rd)
}

func (cn *Conn) WithWriter(
        ctx context.Context, timeout time.Duration, fn func(wr *proto.Writer) error,
) error {
        if timeout >= 0 {
                if err := cn.netConn.SetWriteDeadline(cn.deadline(ctx, timeout)); err != nil {
                        return err
                }
        }

        if cn.bw.Buffered() > 0 {
                cn.bw.Reset(cn.netConn)
        }

        if err := fn(cn.wr); err != nil {
                return err
        }

        return cn.bw.Flush()
}

func (cn *Conn) Close() error {
        if cn.onClose != nil {
                // ignore error
                _ = cn.onClose()
        }
        return cn.netConn.Close()
}

func (cn *Conn) deadline(ctx context.Context, timeout time.Duration) time.Time {
        tm := time.Now()
        cn.SetUsedAt(tm)

        if timeout > 0 {
                tm = tm.Add(timeout)
        }

        if ctx != nil {
                deadline, ok := ctx.Deadline()
                if ok {
                        if timeout == 0 {
                                return deadline
                        }
                        if deadline.Before(tm) {
                                return deadline
                        }
                        return tm
                }
        }

        if timeout > 0 {
                return tm
        }

        return noDeadline
}

//go:build linux || darwin || dragonfly || freebsd || netbsd || openbsd || solaris || illumos

package pool

import (
        "errors"
        "io"
        "net"
        "syscall"
        "time"
)

var errUnexpectedRead = errors.New("unexpected read from socket")

func connCheck(conn net.Conn) error {
        // Reset previous timeout.
        _ = conn.SetDeadline(time.Time{})

        sysConn, ok := conn.(syscall.Conn)
        if !ok {
                return nil
        }
        rawConn, err := sysConn.SyscallConn()
        if err != nil {
                return err
        }

        var sysErr error

        if err := rawConn.Read(func(fd uintptr) bool {
                var buf [1]byte
                n, err := syscall.Read(int(fd), buf[:])
                switch {
                case n == 0 && err == nil:
                        sysErr = io.EOF
                case n > 0:
                        sysErr = errUnexpectedRead
                case err == syscall.EAGAIN || err == syscall.EWOULDBLOCK:
                        sysErr = nil
                default:
                        sysErr = err
                }
                return true
        }); err != nil {
                return err
        }

        return sysErr
}

package pool

import (
        "context"
        "errors"
        "net"
        "sync"
        "sync/atomic"
        "time"

        "github.com/redis/go-redis/v9/internal"
)

var (
        // ErrClosed performs any operation on the closed client will return this error.
        ErrClosed = errors.New("redis: client is closed")

        // ErrPoolExhausted is returned from a pool connection method
        // when the maximum number of database connections in the pool has been reached.
        ErrPoolExhausted = errors.New("redis: connection pool exhausted")

        // ErrPoolTimeout timed out waiting to get a connection from the connection pool.
        ErrPoolTimeout = errors.New("redis: connection pool timeout")
)

var timers = sync.Pool{
        New: func() interface{} {
                t := time.NewTimer(time.Hour)
                t.Stop()
                return t
        },
}

// Stats contains pool state information and accumulated stats.
type Stats struct {
        Hits           uint32 // number of times free connection was found in the pool
        Misses         uint32 // number of times free connection was NOT found in the pool
        Timeouts       uint32 // number of times a wait timeout occurred
        WaitCount      uint32 // number of times a connection was waited
        WaitDurationNs int64  // total time spent for waiting a connection in nanoseconds

        TotalConns uint32 // number of total connections in the pool
        IdleConns  uint32 // number of idle connections in the pool
        StaleConns uint32 // number of stale connections removed from the pool
}

type Pooler interface {
        NewConn(context.Context) (*Conn, error)
        CloseConn(*Conn) error

        Get(context.Context) (*Conn, error)
        Put(context.Context, *Conn)
        Remove(context.Context, *Conn, error)

        Len() int
        IdleLen() int
        Stats() *Stats

        Close() error
}

type Options struct {
        Dialer func(context.Context) (net.Conn, error)

        PoolFIFO        bool
        PoolSize        int
        DialTimeout     time.Duration
        PoolTimeout     time.Duration
        MinIdleConns    int
        MaxIdleConns    int
        MaxActiveConns  int
        ConnMaxIdleTime time.Duration
        ConnMaxLifetime time.Duration
}

type lastDialErrorWrap struct {
        err error
}

type ConnPool struct {
        cfg *Options

        dialErrorsNum uint32 // atomic
        lastDialError atomic.Value

        queue chan struct{}

        connsMu   sync.Mutex
        conns     []*Conn
        idleConns []*Conn

        poolSize     int
        idleConnsLen int

        stats          Stats
        waitDurationNs atomic.Int64

        _closed uint32 // atomic
}

var _ Pooler = (*ConnPool)(nil)

func NewConnPool(opt *Options) *ConnPool {
        p := &ConnPool{
                cfg: opt,

                queue:     make(chan struct{}, opt.PoolSize),
                conns:     make([]*Conn, 0, opt.PoolSize),
                idleConns: make([]*Conn, 0, opt.PoolSize),
        }

        p.connsMu.Lock()
        p.checkMinIdleConns()
        p.connsMu.Unlock()

        return p
}

func (p *ConnPool) checkMinIdleConns() {
        if p.cfg.MinIdleConns == 0 {
                return
        }
        for p.poolSize < p.cfg.PoolSize && p.idleConnsLen < p.cfg.MinIdleConns {
                select {
                case p.queue <- struct{}{}:
                        p.poolSize++
                        p.idleConnsLen++

                        go func() {
                                err := p.addIdleConn()
                                if err != nil && err != ErrClosed {
                                        p.connsMu.Lock()
                                        p.poolSize--
                                        p.idleConnsLen--
                                        p.connsMu.Unlock()
                                }

                                p.freeTurn()
                        }()
                default:
                        return
                }
        }
}

func (p *ConnPool) addIdleConn() error {
        ctx, cancel := context.WithTimeout(context.Background(), p.cfg.DialTimeout)
        defer cancel()

        cn, err := p.dialConn(ctx, true)
        if err != nil {
                return err
        }

        p.connsMu.Lock()
        defer p.connsMu.Unlock()

        // It is not allowed to add new connections to the closed connection pool.
        if p.closed() {
                _ = cn.Close()
                return ErrClosed
        }

        p.conns = append(p.conns, cn)
        p.idleConns = append(p.idleConns, cn)
        return nil
}

func (p *ConnPool) NewConn(ctx context.Context) (*Conn, error) {
        return p.newConn(ctx, false)
}

func (p *ConnPool) newConn(ctx context.Context, pooled bool) (*Conn, error) {
        if p.closed() {
                return nil, ErrClosed
        }

        p.connsMu.Lock()
        if p.cfg.MaxActiveConns > 0 && p.poolSize >= p.cfg.MaxActiveConns {
                p.connsMu.Unlock()
                return nil, ErrPoolExhausted
        }
        p.connsMu.Unlock()

        cn, err := p.dialConn(ctx, pooled)
        if err != nil {
                return nil, err
        }

        p.connsMu.Lock()
        defer p.connsMu.Unlock()

        if p.cfg.MaxActiveConns > 0 && p.poolSize >= p.cfg.MaxActiveConns {
                _ = cn.Close()
                return nil, ErrPoolExhausted
        }

        p.conns = append(p.conns, cn)
        if pooled {
                // If pool is full remove the cn on next Put.
                if p.poolSize >= p.cfg.PoolSize {
                        cn.pooled = false
                } else {
                        p.poolSize++
                }
        }

        return cn, nil
}

func (p *ConnPool) dialConn(ctx context.Context, pooled bool) (*Conn, error) {
        if p.closed() {
                return nil, ErrClosed
        }

        if atomic.LoadUint32(&p.dialErrorsNum) >= uint32(p.cfg.PoolSize) {
                return nil, p.getLastDialError()
        }

        netConn, err := p.cfg.Dialer(ctx)
        if err != nil {
                p.setLastDialError(err)
                if atomic.AddUint32(&p.dialErrorsNum, 1) == uint32(p.cfg.PoolSize) {
                        go p.tryDial()
                }
                return nil, err
        }

        cn := NewConn(netConn)
        cn.pooled = pooled
        return cn, nil
}

func (p *ConnPool) tryDial() {
        for {
                if p.closed() {
                        return
                }

                ctx, cancel := context.WithTimeout(context.Background(), p.cfg.DialTimeout)

                conn, err := p.cfg.Dialer(ctx)
                if err != nil {
                        p.setLastDialError(err)
                        time.Sleep(time.Second)
                        cancel()
                        continue
                }

                atomic.StoreUint32(&p.dialErrorsNum, 0)
                _ = conn.Close()
                cancel()
                return
        }
}

func (p *ConnPool) setLastDialError(err error) {
        p.lastDialError.Store(&lastDialErrorWrap{err: err})
}

func (p *ConnPool) getLastDialError() error {
        err, _ := p.lastDialError.Load().(*lastDialErrorWrap)
        if err != nil {
                return err.err
        }
        return nil
}

// Get returns existed connection from the pool or creates a new one.
func (p *ConnPool) Get(ctx context.Context) (*Conn, error) {
        if p.closed() {
                return nil, ErrClosed
        }

        if err := p.waitTurn(ctx); err != nil {
                return nil, err
        }

        for {
                p.connsMu.Lock()
                cn, err := p.popIdle()
                p.connsMu.Unlock()

                if err != nil {
                        p.freeTurn()
                        return nil, err
                }

                if cn == nil {
                        break
                }

                if !p.isHealthyConn(cn) {
                        _ = p.CloseConn(cn)
                        continue
                }

                atomic.AddUint32(&p.stats.Hits, 1)
                return cn, nil
        }

        atomic.AddUint32(&p.stats.Misses, 1)

        newcn, err := p.newConn(ctx, true)
        if err != nil {
                p.freeTurn()
                return nil, err
        }

        return newcn, nil
}

func (p *ConnPool) waitTurn(ctx context.Context) error {
        select {
        case <-ctx.Done():
                return ctx.Err()
        default:
        }

        select {
        case p.queue <- struct{}{}:
                return nil
        default:
        }

        start := time.Now()
        timer := timers.Get().(*time.Timer)
        defer timers.Put(timer)
        timer.Reset(p.cfg.PoolTimeout)

        select {
        case <-ctx.Done():
                if !timer.Stop() {
                        <-timer.C
                }
                return ctx.Err()
        case p.queue <- struct{}{}:
                p.waitDurationNs.Add(time.Since(start).Nanoseconds())
                atomic.AddUint32(&p.stats.WaitCount, 1)
                if !timer.Stop() {
                        <-timer.C
                }
                return nil
        case <-timer.C:
                atomic.AddUint32(&p.stats.Timeouts, 1)
                return ErrPoolTimeout
        }
}

func (p *ConnPool) freeTurn() {
        <-p.queue
}

func (p *ConnPool) popIdle() (*Conn, error) {
        if p.closed() {
                return nil, ErrClosed
        }
        n := len(p.idleConns)
        if n == 0 {
                return nil, nil
        }

        var cn *Conn
        if p.cfg.PoolFIFO {
                cn = p.idleConns[0]
                copy(p.idleConns, p.idleConns[1:])
                p.idleConns = p.idleConns[:n-1]
        } else {
                idx := n - 1
                cn = p.idleConns[idx]
                p.idleConns = p.idleConns[:idx]
        }
        p.idleConnsLen--
        p.checkMinIdleConns()
        return cn, nil
}

func (p *ConnPool) Put(ctx context.Context, cn *Conn) {
        if cn.rd.Buffered() > 0 {
                internal.Logger.Printf(ctx, "Conn has unread data")
                p.Remove(ctx, cn, BadConnError{})
                return
        }

        if !cn.pooled {
                p.Remove(ctx, cn, nil)
                return
        }

        var shouldCloseConn bool

        p.connsMu.Lock()

        if p.cfg.MaxIdleConns == 0 || p.idleConnsLen < p.cfg.MaxIdleConns {
                p.idleConns = append(p.idleConns, cn)
                p.idleConnsLen++
        } else {
                p.removeConn(cn)
                shouldCloseConn = true
        }

        p.connsMu.Unlock()

        p.freeTurn()

        if shouldCloseConn {
                _ = p.closeConn(cn)
        }
}

func (p *ConnPool) Remove(_ context.Context, cn *Conn, reason error) {
        p.removeConnWithLock(cn)
        p.freeTurn()
        _ = p.closeConn(cn)
}

func (p *ConnPool) CloseConn(cn *Conn) error {
        p.removeConnWithLock(cn)
        return p.closeConn(cn)
}

func (p *ConnPool) removeConnWithLock(cn *Conn) {
        p.connsMu.Lock()
        defer p.connsMu.Unlock()
        p.removeConn(cn)
}

func (p *ConnPool) removeConn(cn *Conn) {
        for i, c := range p.conns {
                if c == cn {
                        p.conns = append(p.conns[:i], p.conns[i+1:]...)
                        if cn.pooled {
                                p.poolSize--
                                p.checkMinIdleConns()
                        }
                        break
                }
        }
        atomic.AddUint32(&p.stats.StaleConns, 1)
}

func (p *ConnPool) closeConn(cn *Conn) error {
        return cn.Close()
}

// Len returns total number of connections.
func (p *ConnPool) Len() int {
        p.connsMu.Lock()
        n := len(p.conns)
        p.connsMu.Unlock()
        return n
}

// IdleLen returns number of idle connections.
func (p *ConnPool) IdleLen() int {
        p.connsMu.Lock()
        n := p.idleConnsLen
        p.connsMu.Unlock()
        return n
}

func (p *ConnPool) Stats() *Stats {
        return &Stats{
                Hits:           atomic.LoadUint32(&p.stats.Hits),
                Misses:         atomic.LoadUint32(&p.stats.Misses),
                Timeouts:       atomic.LoadUint32(&p.stats.Timeouts),
                WaitCount:      atomic.LoadUint32(&p.stats.WaitCount),
                WaitDurationNs: p.waitDurationNs.Load(),

                TotalConns: uint32(p.Len()),
                IdleConns:  uint32(p.IdleLen()),
                StaleConns: atomic.LoadUint32(&p.stats.StaleConns),
        }
}

func (p *ConnPool) closed() bool {
        return atomic.LoadUint32(&p._closed) == 1
}

func (p *ConnPool) Filter(fn func(*Conn) bool) error {
        p.connsMu.Lock()
        defer p.connsMu.Unlock()

        var firstErr error
        for _, cn := range p.conns {
                if fn(cn) {
                        if err := p.closeConn(cn); err != nil && firstErr == nil {
                                firstErr = err
                        }
                }
        }
        return firstErr
}

func (p *ConnPool) Close() error {
        if !atomic.CompareAndSwapUint32(&p._closed, 0, 1) {
                return ErrClosed
        }

        var firstErr error
        p.connsMu.Lock()
        for _, cn := range p.conns {
                if err := p.closeConn(cn); err != nil && firstErr == nil {
                        firstErr = err
                }
        }
        p.conns = nil
        p.poolSize = 0
        p.idleConns = nil
        p.idleConnsLen = 0
        p.connsMu.Unlock()

        return firstErr
}

func (p *ConnPool) isHealthyConn(cn *Conn) bool {
        now := time.Now()

        if p.cfg.ConnMaxLifetime > 0 && now.Sub(cn.createdAt) >= p.cfg.ConnMaxLifetime {
                return false
        }
        if p.cfg.ConnMaxIdleTime > 0 && now.Sub(cn.UsedAt()) >= p.cfg.ConnMaxIdleTime {
                return false
        }

        if connCheck(cn.netConn) != nil {
                return false
        }

        cn.SetUsedAt(now)
        return true
}

package pool

import "context"

type SingleConnPool struct {
        pool      Pooler
        cn        *Conn
        stickyErr error
}

var _ Pooler = (*SingleConnPool)(nil)

func NewSingleConnPool(pool Pooler, cn *Conn) *SingleConnPool {
        return &SingleConnPool{
                pool: pool,
                cn:   cn,
        }
}

func (p *SingleConnPool) NewConn(ctx context.Context) (*Conn, error) {
        return p.pool.NewConn(ctx)
}

func (p *SingleConnPool) CloseConn(cn *Conn) error {
        return p.pool.CloseConn(cn)
}

func (p *SingleConnPool) Get(ctx context.Context) (*Conn, error) {
        if p.stickyErr != nil {
                return nil, p.stickyErr
        }
        return p.cn, nil
}

func (p *SingleConnPool) Put(ctx context.Context, cn *Conn) {}

func (p *SingleConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
        p.cn = nil
        p.stickyErr = reason
}

func (p *SingleConnPool) Close() error {
        p.cn = nil
        p.stickyErr = ErrClosed
        return nil
}

func (p *SingleConnPool) Len() int {
        return 0
}

func (p *SingleConnPool) IdleLen() int {
        return 0
}

func (p *SingleConnPool) Stats() *Stats {
        return &Stats{}
}

package pool

import (
        "context"
        "errors"
        "fmt"
        "sync/atomic"
)

const (
        stateDefault = 0
        stateInited  = 1
        stateClosed  = 2
)

type BadConnError struct {
        wrapped error
}

var _ error = (*BadConnError)(nil)

func (e BadConnError) Error() string {
        s := "redis: Conn is in a bad state"
        if e.wrapped != nil {
                s += ": " + e.wrapped.Error()
        }
        return s
}

func (e BadConnError) Unwrap() error {
        return e.wrapped
}

//------------------------------------------------------------------------------

type StickyConnPool struct {
        pool   Pooler
        shared int32 // atomic

        state uint32 // atomic
        ch    chan *Conn

        _badConnError atomic.Value
}

var _ Pooler = (*StickyConnPool)(nil)

func NewStickyConnPool(pool Pooler) *StickyConnPool {
        p, ok := pool.(*StickyConnPool)
        if !ok {
                p = &StickyConnPool{
                        pool: pool,
                        ch:   make(chan *Conn, 1),
                }
        }
        atomic.AddInt32(&p.shared, 1)
        return p
}

func (p *StickyConnPool) NewConn(ctx context.Context) (*Conn, error) {
        return p.pool.NewConn(ctx)
}

func (p *StickyConnPool) CloseConn(cn *Conn) error {
        return p.pool.CloseConn(cn)
}

func (p *StickyConnPool) Get(ctx context.Context) (*Conn, error) {
        // In worst case this races with Close which is not a very common operation.
        for i := 0; i < 1000; i++ {
                switch atomic.LoadUint32(&p.state) {
                case stateDefault:
                        cn, err := p.pool.Get(ctx)
                        if err != nil {
                                return nil, err
                        }
                        if atomic.CompareAndSwapUint32(&p.state, stateDefault, stateInited) {
                                return cn, nil
                        }
                        p.pool.Remove(ctx, cn, ErrClosed)
                case stateInited:
                        if err := p.badConnError(); err != nil {
                                return nil, err
                        }
                        cn, ok := <-p.ch
                        if !ok {
                                return nil, ErrClosed
                        }
                        return cn, nil
                case stateClosed:
                        return nil, ErrClosed
                default:
                        panic("not reached")
                }
        }
        return nil, fmt.Errorf("redis: StickyConnPool.Get: infinite loop")
}

func (p *StickyConnPool) Put(ctx context.Context, cn *Conn) {
        defer func() {
                if recover() != nil {
                        p.freeConn(ctx, cn)
                }
        }()
        p.ch <- cn
}

func (p *StickyConnPool) freeConn(ctx context.Context, cn *Conn) {
        if err := p.badConnError(); err != nil {
                p.pool.Remove(ctx, cn, err)
        } else {
                p.pool.Put(ctx, cn)
        }
}

func (p *StickyConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
        defer func() {
                if recover() != nil {
                        p.pool.Remove(ctx, cn, ErrClosed)
                }
        }()
        p._badConnError.Store(BadConnError{wrapped: reason})
        p.ch <- cn
}

func (p *StickyConnPool) Close() error {
        if shared := atomic.AddInt32(&p.shared, -1); shared > 0 {
                return nil
        }

        for i := 0; i < 1000; i++ {
                state := atomic.LoadUint32(&p.state)
                if state == stateClosed {
                        return ErrClosed
                }
                if atomic.CompareAndSwapUint32(&p.state, state, stateClosed) {
                        close(p.ch)
                        cn, ok := <-p.ch
                        if ok {
                                p.freeConn(context.TODO(), cn)
                        }
                        return nil
                }
        }

        return errors.New("redis: StickyConnPool.Close: infinite loop")
}

func (p *StickyConnPool) Reset(ctx context.Context) error {
        if p.badConnError() == nil {
                return nil
        }

        select {
        case cn, ok := <-p.ch:
                if !ok {
                        return ErrClosed
                }
                p.pool.Remove(ctx, cn, ErrClosed)
                p._badConnError.Store(BadConnError{wrapped: nil})
        default:
                return errors.New("redis: StickyConnPool does not have a Conn")
        }

        if !atomic.CompareAndSwapUint32(&p.state, stateInited, stateDefault) {
                state := atomic.LoadUint32(&p.state)
                return fmt.Errorf("redis: invalid StickyConnPool state: %d", state)
        }

        return nil
}

func (p *StickyConnPool) badConnError() error {
        if v := p._badConnError.Load(); v != nil {
                if err := v.(BadConnError); err.wrapped != nil {
                        return err
                }
        }
        return nil
}

func (p *StickyConnPool) Len() int {
        switch atomic.LoadUint32(&p.state) {
        case stateDefault:
                return 0
        case stateInited:
                return 1
        case stateClosed:
                return 0
        default:
                panic("not reached")
        }
}

func (p *StickyConnPool) IdleLen() int {
        return len(p.ch)
}

func (p *StickyConnPool) Stats() *Stats {
        return &Stats{}
}

package proto

import (
        "bufio"
        "errors"
        "fmt"
        "io"
        "math"
        "math/big"
        "strconv"

        "github.com/redis/go-redis/v9/internal/util"
)

// redis resp protocol data type.
const (
        RespStatus    = '+' // +<string>\r\n
        RespError     = '-' // -<string>\r\n
        RespString    = '$' // $<length>\r\n<bytes>\r\n
        RespInt       = ':' // :<number>\r\n
        RespNil       = '_' // _\r\n
        RespFloat     = ',' // ,<floating-point-number>\r\n (golang float)
        RespBool      = '#' // true: #t\r\n false: #f\r\n
        RespBlobError = '!' // !<length>\r\n<bytes>\r\n
        RespVerbatim  = '=' // =<length>\r\nFORMAT:<bytes>\r\n
        RespBigInt    = '(' // (<big number>\r\n
        RespArray     = '*' // *<len>\r\n... (same as resp2)
        RespMap       = '%' // %<len>\r\n(key)\r\n(value)\r\n... (golang map)
        RespSet       = '~' // ~<len>\r\n... (same as Array)
        RespAttr      = '|' // |<len>\r\n(key)\r\n(value)\r\n... + command reply
        RespPush      = '>' // ><len>\r\n... (same as Array)
)

// Not used temporarily.
// Redis has not used these two data types for the time being, and will implement them later.
// Streamed           = "EOF:"
// StreamedAggregated = '?'

//------------------------------------------------------------------------------

const Nil = RedisError("redis: nil") // nolint:errname

type RedisError string

func (e RedisError) Error() string { return string(e) }

func (RedisError) RedisError() {}

func ParseErrorReply(line []byte) error {
        return RedisError(line[1:])
}

//------------------------------------------------------------------------------

type Reader struct {
        rd *bufio.Reader
}

func NewReader(rd io.Reader) *Reader {
        return &Reader{
                rd: bufio.NewReader(rd),
        }
}

func (r *Reader) Buffered() int {
        return r.rd.Buffered()
}

func (r *Reader) Peek(n int) ([]byte, error) {
        return r.rd.Peek(n)
}

func (r *Reader) Reset(rd io.Reader) {
        r.rd.Reset(rd)
}

// PeekReplyType returns the data type of the next response without advancing the Reader,
// and discard the attribute type.
func (r *Reader) PeekReplyType() (byte, error) {
        b, err := r.rd.Peek(1)
        if err != nil {
                return 0, err
        }
        if b[0] == RespAttr {
                if err = r.DiscardNext(); err != nil {
                        return 0, err
                }
                return r.PeekReplyType()
        }
        return b[0], nil
}

// ReadLine Return a valid reply, it will check the protocol or redis error,
// and discard the attribute type.
func (r *Reader) ReadLine() ([]byte, error) {
        line, err := r.readLine()
        if err != nil {
                return nil, err
        }
        switch line[0] {
        case RespError:
                return nil, ParseErrorReply(line)
        case RespNil:
                return nil, Nil
        case RespBlobError:
                var blobErr string
                blobErr, err = r.readStringReply(line)
                if err == nil {
                        err = RedisError(blobErr)
                }
                return nil, err
        case RespAttr:
                if err = r.Discard(line); err != nil {
                        return nil, err
                }
                return r.ReadLine()
        }

        // Compatible with RESP2
        if IsNilReply(line) {
                return nil, Nil
        }

        return line, nil
}

// readLine returns an error if:
//   - there is a pending read error;
//   - or line does not end with \r\n.
func (r *Reader) readLine() ([]byte, error) {
        b, err := r.rd.ReadSlice('\n')
        if err != nil {
                if err != bufio.ErrBufferFull {
                        return nil, err
                }

                full := make([]byte, len(b))
                copy(full, b)

                b, err = r.rd.ReadBytes('\n')
                if err != nil {
                        return nil, err
                }

                full = append(full, b...) //nolint:makezero
                b = full
        }
        if len(b) <= 2 || b[len(b)-1] != '\n' || b[len(b)-2] != '\r' {
                return nil, fmt.Errorf("redis: invalid reply: %q", b)
        }
        return b[:len(b)-2], nil
}

func (r *Reader) ReadReply() (interface{}, error) {
        line, err := r.ReadLine()
        if err != nil {
                return nil, err
        }

        switch line[0] {
        case RespStatus:
                return string(line[1:]), nil
        case RespInt:
                return util.ParseInt(line[1:], 10, 64)
        case RespFloat:
                return r.readFloat(line)
        case RespBool:
                return r.readBool(line)
        case RespBigInt:
                return r.readBigInt(line)

        case RespString:
                return r.readStringReply(line)
        case RespVerbatim:
                return r.readVerb(line)

        case RespArray, RespSet, RespPush:
                return r.readSlice(line)
        case RespMap:
                return r.readMap(line)
        }
        return nil, fmt.Errorf("redis: can't parse %.100q", line)
}

func (r *Reader) readFloat(line []byte) (float64, error) {
        v := string(line[1:])
        switch string(line[1:]) {
        case "inf":
                return math.Inf(1), nil
        case "-inf":
                return math.Inf(-1), nil
        case "nan", "-nan":
                return math.NaN(), nil
        }
        return strconv.ParseFloat(v, 64)
}

func (r *Reader) readBool(line []byte) (bool, error) {
        switch string(line[1:]) {
        case "t":
                return true, nil
        case "f":
                return false, nil
        }
        return false, fmt.Errorf("redis: can't parse bool reply: %q", line)
}

func (r *Reader) readBigInt(line []byte) (*big.Int, error) {
        i := new(big.Int)
        if i, ok := i.SetString(string(line[1:]), 10); ok {
                return i, nil
        }
        return nil, fmt.Errorf("redis: can't parse bigInt reply: %q", line)
}

func (r *Reader) readStringReply(line []byte) (string, error) {
        n, err := replyLen(line)
        if err != nil {
                return "", err
        }

        b := make([]byte, n+2)
        _, err = io.ReadFull(r.rd, b)
        if err != nil {
                return "", err
        }

        return util.BytesToString(b[:n]), nil
}

func (r *Reader) readVerb(line []byte) (string, error) {
        s, err := r.readStringReply(line)
        if err != nil {
                return "", err
        }
        if len(s) < 4 || s[3] != ':' {
                return "", fmt.Errorf("redis: can't parse verbatim string reply: %q", line)
        }
        return s[4:], nil
}

func (r *Reader) readSlice(line []byte) ([]interface{}, error) {
        n, err := replyLen(line)
        if err != nil {
                return nil, err
        }

        val := make([]interface{}, n)
        for i := 0; i < len(val); i++ {
                v, err := r.ReadReply()
                if err != nil {
                        if err == Nil {
                                val[i] = nil
                                continue
                        }
                        if err, ok := err.(RedisError); ok {
                                val[i] = err
                                continue
                        }
                        return nil, err
                }
                val[i] = v
        }
        return val, nil
}

func (r *Reader) readMap(line []byte) (map[interface{}]interface{}, error) {
        n, err := replyLen(line)
        if err != nil {
                return nil, err
        }
        m := make(map[interface{}]interface{}, n)
        for i := 0; i < n; i++ {
                k, err := r.ReadReply()
                if err != nil {
                        return nil, err
                }
                v, err := r.ReadReply()
                if err != nil {
                        if err == Nil {
                                m[k] = nil
                                continue
                        }
                        if err, ok := err.(RedisError); ok {
                                m[k] = err
                                continue
                        }
                        return nil, err
                }
                m[k] = v
        }
        return m, nil
}

// -------------------------------

func (r *Reader) ReadInt() (int64, error) {
        line, err := r.ReadLine()
        if err != nil {
                return 0, err
        }
        switch line[0] {
        case RespInt, RespStatus:
                return util.ParseInt(line[1:], 10, 64)
        case RespString:
                s, err := r.readStringReply(line)
                if err != nil {
                        return 0, err
                }
                return util.ParseInt([]byte(s), 10, 64)
        case RespBigInt:
                b, err := r.readBigInt(line)
                if err != nil {
                        return 0, err
                }
                if !b.IsInt64() {
                        return 0, fmt.Errorf("bigInt(%s) value out of range", b.String())
                }
                return b.Int64(), nil
        }
        return 0, fmt.Errorf("redis: can't parse int reply: %.100q", line)
}

func (r *Reader) ReadUint() (uint64, error) {
        line, err := r.ReadLine()
        if err != nil {
                return 0, err
        }
        switch line[0] {
        case RespInt, RespStatus:
                return util.ParseUint(line[1:], 10, 64)
        case RespString:
                s, err := r.readStringReply(line)
                if err != nil {
                        return 0, err
                }
                return util.ParseUint([]byte(s), 10, 64)
        case RespBigInt:
                b, err := r.readBigInt(line)
                if err != nil {
                        return 0, err
                }
                if !b.IsUint64() {
                        return 0, fmt.Errorf("bigInt(%s) value out of range", b.String())
                }
                return b.Uint64(), nil
        }
        return 0, fmt.Errorf("redis: can't parse uint reply: %.100q", line)
}

func (r *Reader) ReadFloat() (float64, error) {
        line, err := r.ReadLine()
        if err != nil {
                return 0, err
        }
        switch line[0] {
        case RespFloat:
                return r.readFloat(line)
        case RespStatus:
                return strconv.ParseFloat(string(line[1:]), 64)
        case RespString:
                s, err := r.readStringReply(line)
                if err != nil {
                        return 0, err
                }
                return strconv.ParseFloat(s, 64)
        }
        return 0, fmt.Errorf("redis: can't parse float reply: %.100q", line)
}

func (r *Reader) ReadString() (string, error) {
        line, err := r.ReadLine()
        if err != nil {
                return "", err
        }

        switch line[0] {
        case RespStatus, RespInt, RespFloat:
                return string(line[1:]), nil
        case RespString:
                return r.readStringReply(line)
        case RespBool:
                b, err := r.readBool(line)
                return strconv.FormatBool(b), err
        case RespVerbatim:
                return r.readVerb(line)
        case RespBigInt:
                b, err := r.readBigInt(line)
                if err != nil {
                        return "", err
                }
                return b.String(), nil
        }
        return "", fmt.Errorf("redis: can't parse reply=%.100q reading string", line)
}

func (r *Reader) ReadBool() (bool, error) {
        s, err := r.ReadString()
        if err != nil {
                return false, err
        }
        return s == "OK" || s == "1" || s == "true", nil
}

func (r *Reader) ReadSlice() ([]interface{}, error) {
        line, err := r.ReadLine()
        if err != nil {
                return nil, err
        }
        return r.readSlice(line)
}

// ReadFixedArrayLen read fixed array length.
func (r *Reader) ReadFixedArrayLen(fixedLen int) error {
        n, err := r.ReadArrayLen()
        if err != nil {
                return err
        }
        if n != fixedLen {
                return fmt.Errorf("redis: got %d elements in the array, wanted %d", n, fixedLen)
        }
        return nil
}

// ReadArrayLen Read and return the length of the array.
func (r *Reader) ReadArrayLen() (int, error) {
        line, err := r.ReadLine()
        if err != nil {
                return 0, err
        }
        switch line[0] {
        case RespArray, RespSet, RespPush:
                return replyLen(line)
        default:
                return 0, fmt.Errorf("redis: can't parse array/set/push reply: %.100q", line)
        }
}

// ReadFixedMapLen reads fixed map length.
func (r *Reader) ReadFixedMapLen(fixedLen int) error {
        n, err := r.ReadMapLen()
        if err != nil {
                return err
        }
        if n != fixedLen {
                return fmt.Errorf("redis: got %d elements in the map, wanted %d", n, fixedLen)
        }
        return nil
}

// ReadMapLen reads the length of the map type.
// If responding to the array type (RespArray/RespSet/RespPush),
// it must be a multiple of 2 and return n/2.
// Other types will return an error.
func (r *Reader) ReadMapLen() (int, error) {
        line, err := r.ReadLine()
        if err != nil {
                return 0, err
        }
        switch line[0] {
        case RespMap:
                return replyLen(line)
        case RespArray, RespSet, RespPush:
                // Some commands and RESP2 protocol may respond to array types.
                n, err := replyLen(line)
                if err != nil {
                        return 0, err
                }
                if n%2 != 0 {
                        return 0, fmt.Errorf("redis: the length of the array must be a multiple of 2, got: %d", n)
                }
                return n / 2, nil
        default:
                return 0, fmt.Errorf("redis: can't parse map reply: %.100q", line)
        }
}

// DiscardNext read and discard the data represented by the next line.
func (r *Reader) DiscardNext() error {
        line, err := r.readLine()
        if err != nil {
                return err
        }
        return r.Discard(line)
}

// Discard the data represented by line.
func (r *Reader) Discard(line []byte) (err error) {
        if len(line) == 0 {
                return errors.New("redis: invalid line")
        }
        switch line[0] {
        case RespStatus, RespError, RespInt, RespNil, RespFloat, RespBool, RespBigInt:
                return nil
        }

        n, err := replyLen(line)
        if err != nil && err != Nil {
                return err
        }

        switch line[0] {
        case RespBlobError, RespString, RespVerbatim:
                // +\r\n
                _, err = r.rd.Discard(n + 2)
                return err
        case RespArray, RespSet, RespPush:
                for i := 0; i < n; i++ {
                        if err = r.DiscardNext(); err != nil {
                                return err
                        }
                }
                return nil
        case RespMap, RespAttr:
                // Read key & value.
                for i := 0; i < n*2; i++ {
                        if err = r.DiscardNext(); err != nil {
                                return err
                        }
                }
                return nil
        }

        return fmt.Errorf("redis: can't parse %.100q", line)
}

func replyLen(line []byte) (n int, err error) {
        n, err = util.Atoi(line[1:])
        if err != nil {
                return 0, err
        }

        if n < -1 {
                return 0, fmt.Errorf("redis: invalid reply: %q", line)
        }

        switch line[0] {
        case RespString, RespVerbatim, RespBlobError,
                RespArray, RespSet, RespPush, RespMap, RespAttr:
                if n == -1 {
                        return 0, Nil
                }
        }
        return n, nil
}

// IsNilReply detects redis.Nil of RESP2.
func IsNilReply(line []byte) bool {
        return len(line) == 3 &&
                (line[0] == RespString || line[0] == RespArray) &&
                line[1] == '-' && line[2] == '1'
}

package proto

import (
        "encoding"
        "fmt"
        "net"
        "reflect"
        "time"

        "github.com/redis/go-redis/v9/internal/util"
)

// Scan parses bytes `b` to `v` with appropriate type.
//
//nolint:gocyclo
func Scan(b []byte, v interface{}) error {
        switch v := v.(type) {
        case nil:
                return fmt.Errorf("redis: Scan(nil)")
        case *string:
                *v = util.BytesToString(b)
                return nil
        case *[]byte:
                *v = b
                return nil
        case *int:
                var err error
                *v, err = util.Atoi(b)
                return err
        case *int8:
                n, err := util.ParseInt(b, 10, 8)
                if err != nil {
                        return err
                }
                *v = int8(n)
                return nil
        case *int16:
                n, err := util.ParseInt(b, 10, 16)
                if err != nil {
                        return err
                }
                *v = int16(n)
                return nil
        case *int32:
                n, err := util.ParseInt(b, 10, 32)
                if err != nil {
                        return err
                }
                *v = int32(n)
                return nil
        case *int64:
                n, err := util.ParseInt(b, 10, 64)
                if err != nil {
                        return err
                }
                *v = n
                return nil
        case *uint:
                n, err := util.ParseUint(b, 10, 64)
                if err != nil {
                        return err
                }
                *v = uint(n)
                return nil
        case *uint8:
                n, err := util.ParseUint(b, 10, 8)
                if err != nil {
                        return err
                }
                *v = uint8(n)
                return nil
        case *uint16:
                n, err := util.ParseUint(b, 10, 16)
                if err != nil {
                        return err
                }
                *v = uint16(n)
                return nil
        case *uint32:
                n, err := util.ParseUint(b, 10, 32)
                if err != nil {
                        return err
                }
                *v = uint32(n)
                return nil
        case *uint64:
                n, err := util.ParseUint(b, 10, 64)
                if err != nil {
                        return err
                }
                *v = n
                return nil
        case *float32:
                n, err := util.ParseFloat(b, 32)
                if err != nil {
                        return err
                }
                *v = float32(n)
                return err
        case *float64:
                var err error
                *v, err = util.ParseFloat(b, 64)
                return err
        case *bool:
                *v = len(b) == 1 && b[0] == '1'
                return nil
        case *time.Time:
                var err error
                *v, err = time.Parse(time.RFC3339Nano, util.BytesToString(b))
                return err
        case *time.Duration:
                n, err := util.ParseInt(b, 10, 64)
                if err != nil {
                        return err
                }
                *v = time.Duration(n)
                return nil
        case encoding.BinaryUnmarshaler:
                return v.UnmarshalBinary(b)
        case *net.IP:
                *v = b
                return nil
        default:
                return fmt.Errorf(
                        "redis: can't unmarshal %T (consider implementing BinaryUnmarshaler)", v)
        }
}

func ScanSlice(data []string, slice interface{}) error {
        v := reflect.ValueOf(slice)
        if !v.IsValid() {
                return fmt.Errorf("redis: ScanSlice(nil)")
        }
        if v.Kind() != reflect.Ptr {
                return fmt.Errorf("redis: ScanSlice(non-pointer %T)", slice)
        }
        v = v.Elem()
        if v.Kind() != reflect.Slice {
                return fmt.Errorf("redis: ScanSlice(non-slice %T)", slice)
        }

        next := makeSliceNextElemFunc(v)
        for i, s := range data {
                elem := next()
                if err := Scan([]byte(s), elem.Addr().Interface()); err != nil {
                        err = fmt.Errorf("redis: ScanSlice index=%d value=%q failed: %w", i, s, err)
                        return err
                }
        }

        return nil
}

func makeSliceNextElemFunc(v reflect.Value) func() reflect.Value {
        elemType := v.Type().Elem()

        if elemType.Kind() == reflect.Ptr {
                elemType = elemType.Elem()
                return func() reflect.Value {
                        if v.Len() < v.Cap() {
                                v.Set(v.Slice(0, v.Len()+1))
                                elem := v.Index(v.Len() - 1)
                                if elem.IsNil() {
                                        elem.Set(reflect.New(elemType))
                                }
                                return elem.Elem()
                        }

                        elem := reflect.New(elemType)
                        v.Set(reflect.Append(v, elem))
                        return elem.Elem()
                }
        }

        zero := reflect.Zero(elemType)
        return func() reflect.Value {
                if v.Len() < v.Cap() {
                        v.Set(v.Slice(0, v.Len()+1))
                        return v.Index(v.Len() - 1)
                }

                v.Set(reflect.Append(v, zero))
                return v.Index(v.Len() - 1)
        }
}

package proto

import (
        "encoding"
        "fmt"
        "io"
        "net"
        "strconv"
        "time"

        "github.com/redis/go-redis/v9/internal/util"
)

type writer interface {
        io.Writer
        io.ByteWriter
        // WriteString implement io.StringWriter.
        WriteString(s string) (n int, err error)
}

type Writer struct {
        writer

        lenBuf []byte
        numBuf []byte
}

func NewWriter(wr writer) *Writer {
        return &Writer{
                writer: wr,

                lenBuf: make([]byte, 64),
                numBuf: make([]byte, 64),
        }
}

func (w *Writer) WriteArgs(args []interface{}) error {
        if err := w.WriteByte(RespArray); err != nil {
                return err
        }

        if err := w.writeLen(len(args)); err != nil {
                return err
        }

        for _, arg := range args {
                if err := w.WriteArg(arg); err != nil {
                        return err
                }
        }

        return nil
}

func (w *Writer) writeLen(n int) error {
        w.lenBuf = strconv.AppendUint(w.lenBuf[:0], uint64(n), 10)
        w.lenBuf = append(w.lenBuf, '\r', '\n')
        _, err := w.Write(w.lenBuf)
        return err
}

func (w *Writer) WriteArg(v interface{}) error {
        switch v := v.(type) {
        case nil:
                return w.string("")
        case string:
                return w.string(v)
        case *string:
                if v == nil {
                        return w.string("")
                }
                return w.string(*v)
        case []byte:
                return w.bytes(v)
        case int:
                return w.int(int64(v))
        case *int:
                if v == nil {
                        return w.int(0)
                }
                return w.int(int64(*v))
        case int8:
                return w.int(int64(v))
        case *int8:
                if v == nil {
                        return w.int(0)
                }
                return w.int(int64(*v))
        case int16:
                return w.int(int64(v))
        case *int16:
                if v == nil {
                        return w.int(0)
                }
                return w.int(int64(*v))
        case int32:
                return w.int(int64(v))
        case *int32:
                if v == nil {
                        return w.int(0)
                }
                return w.int(int64(*v))
        case int64:
                return w.int(v)
        case *int64:
                if v == nil {
                        return w.int(0)
                }
                return w.int(*v)
        case uint:
                return w.uint(uint64(v))
        case *uint:
                if v == nil {
                        return w.uint(0)
                }
                return w.uint(uint64(*v))
        case uint8:
                return w.uint(uint64(v))
        case *uint8:
                if v == nil {
                        return w.string("")
                }
                return w.uint(uint64(*v))
        case uint16:
                return w.uint(uint64(v))
        case *uint16:
                if v == nil {
                        return w.uint(0)
                }
                return w.uint(uint64(*v))
        case uint32:
                return w.uint(uint64(v))
        case *uint32:
                if v == nil {
                        return w.uint(0)
                }
                return w.uint(uint64(*v))
        case uint64:
                return w.uint(v)
        case *uint64:
                if v == nil {
                        return w.uint(0)
                }
                return w.uint(*v)
        case float32:
                return w.float(float64(v))
        case *float32:
                if v == nil {
                        return w.float(0)
                }
                return w.float(float64(*v))
        case float64:
                return w.float(v)
        case *float64:
                if v == nil {
                        return w.float(0)
                }
                return w.float(*v)
        case bool:
                if v {
                        return w.int(1)
                }
                return w.int(0)
        case *bool:
                if v == nil {
                        return w.int(0)
                }
                if *v {
                        return w.int(1)
                }
                return w.int(0)
        case time.Time:
                w.numBuf = v.AppendFormat(w.numBuf[:0], time.RFC3339Nano)
                return w.bytes(w.numBuf)
        case *time.Time:
                if v == nil {
                        v = &time.Time{}
                }
                w.numBuf = v.AppendFormat(w.numBuf[:0], time.RFC3339Nano)
                return w.bytes(w.numBuf)
        case time.Duration:
                return w.int(v.Nanoseconds())
        case *time.Duration:
                if v == nil {
                        return w.int(0)
                }
                return w.int(v.Nanoseconds())
        case encoding.BinaryMarshaler:
                b, err := v.MarshalBinary()
                if err != nil {
                        return err
                }
                return w.bytes(b)
        case net.IP:
                return w.bytes(v)
        default:
                return fmt.Errorf(
                        "redis: can't marshal %T (implement encoding.BinaryMarshaler)", v)
        }
}

func (w *Writer) bytes(b []byte) error {
        if err := w.WriteByte(RespString); err != nil {
                return err
        }

        if err := w.writeLen(len(b)); err != nil {
                return err
        }

        if _, err := w.Write(b); err != nil {
                return err
        }

        return w.crlf()
}

func (w *Writer) string(s string) error {
        return w.bytes(util.StringToBytes(s))
}

func (w *Writer) uint(n uint64) error {
        w.numBuf = strconv.AppendUint(w.numBuf[:0], n, 10)
        return w.bytes(w.numBuf)
}

func (w *Writer) int(n int64) error {
        w.numBuf = strconv.AppendInt(w.numBuf[:0], n, 10)
        return w.bytes(w.numBuf)
}

func (w *Writer) float(f float64) error {
        w.numBuf = strconv.AppendFloat(w.numBuf[:0], f, 'f', -1, 64)
        return w.bytes(w.numBuf)
}

func (w *Writer) crlf() error {
        if err := w.WriteByte('\r'); err != nil {
                return err
        }
        return w.WriteByte('\n')
}

package rand

import (
        "math/rand"
        "sync"
)

// Int returns a non-negative pseudo-random int.
func Int() int { return pseudo.Int() }

// Intn returns, as an int, a non-negative pseudo-random number in [0,n).
// It panics if n <= 0.
func Intn(n int) int { return pseudo.Intn(n) }

// Int63n returns, as an int64, a non-negative pseudo-random number in [0,n).
// It panics if n <= 0.
func Int63n(n int64) int64 { return pseudo.Int63n(n) }

// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n).
func Perm(n int) []int { return pseudo.Perm(n) }

// Seed uses the provided seed value to initialize the default Source to a
// deterministic state. If Seed is not called, the generator behaves as if
// seeded by Seed(1).
func Seed(n int64) { pseudo.Seed(n) }

var pseudo = rand.New(&source{src: rand.NewSource(1)})

type source struct {
        src rand.Source
        mu  sync.Mutex
}

func (s *source) Int63() int64 {
        s.mu.Lock()
        n := s.src.Int63()
        s.mu.Unlock()
        return n
}

func (s *source) Seed(seed int64) {
        s.mu.Lock()
        s.src.Seed(seed)
        s.mu.Unlock()
}

// Shuffle pseudo-randomizes the order of elements.
// n is the number of elements.
// swap swaps the elements with indexes i and j.
func Shuffle(n int, swap func(i, j int)) { pseudo.Shuffle(n, swap) }

package internal

import (
        "context"
        "net"
        "strconv"
        "strings"
        "time"

        "github.com/redis/go-redis/v9/internal/util"
)

func Sleep(ctx context.Context, dur time.Duration) error {
        t := time.NewTimer(dur)
        defer t.Stop()

        select {
        case <-t.C:
                return nil
        case <-ctx.Done():
                return ctx.Err()
        }
}

func ToLower(s string) string {
        if isLower(s) {
                return s
        }

        b := make([]byte, len(s))
        for i := range b {
                c := s[i]
                if c >= 'A' && c <= 'Z' {
                        c += 'a' - 'A'
                }
                b[i] = c
        }
        return util.BytesToString(b)
}

func isLower(s string) bool {
        for i := 0; i < len(s); i++ {
                c := s[i]
                if c >= 'A' && c <= 'Z' {
                        return false
                }
        }
        return true
}

func ReplaceSpaces(s string) string {
        return strings.ReplaceAll(s, " ", "-")
}

func GetAddr(addr string) string {
        ind := strings.LastIndexByte(addr, ':')
        if ind == -1 {
                return ""
        }

        if strings.IndexByte(addr, '.') != -1 {
                return addr
        }

        if addr[0] == '[' {
                return addr
        }
        return net.JoinHostPort(addr[:ind], addr[ind+1:])
}

func ToInteger(val interface{}) int {
        switch v := val.(type) {
        case int:
                return v
        case int64:
                return int(v)
        case string:
                i, _ := strconv.Atoi(v)
                return i
        default:
                return 0
        }
}

func ToFloat(val interface{}) float64 {
        switch v := val.(type) {
        case float64:
                return v
        case string:
                f, _ := strconv.ParseFloat(v, 64)
                return f
        default:
                return 0.0
        }
}

func ToString(val interface{}) string {
        if str, ok := val.(string); ok {
                return str
        }
        return ""
}

func ToStringSlice(val interface{}) []string {
        if arr, ok := val.([]interface{}); ok {
                result := make([]string, len(arr))
                for i, v := range arr {
                        result[i] = ToString(v)
                }
                return result
        }
        return nil
}

package util

import (
        "fmt"
        "math"
        "strconv"
)

// ParseFloat parses a Redis RESP3 float reply into a Go float64,
// handling "inf", "-inf", "nan" per Redis conventions.
func ParseStringToFloat(s string) (float64, error) {
        switch s {
        case "inf":
                return math.Inf(1), nil
        case "-inf":
                return math.Inf(-1), nil
        case "nan", "-nan":
                return math.NaN(), nil
        }
        return strconv.ParseFloat(s, 64)
}

// MustParseFloat is like ParseFloat but panics on parse errors.
func MustParseFloat(s string) float64 {
        f, err := ParseStringToFloat(s)
        if err != nil {
                panic(fmt.Sprintf("redis: failed to parse float %q: %v", s, err))
        }
        return f
}

package util

import "strconv"

func Atoi(b []byte) (int, error) {
        return strconv.Atoi(BytesToString(b))
}

func ParseInt(b []byte, base int, bitSize int) (int64, error) {
        return strconv.ParseInt(BytesToString(b), base, bitSize)
}

func ParseUint(b []byte, base int, bitSize int) (uint64, error) {
        return strconv.ParseUint(BytesToString(b), base, bitSize)
}

func ParseFloat(b []byte, bitSize int) (float64, error) {
        return strconv.ParseFloat(BytesToString(b), bitSize)
}

package util

func ToPtr[T any](v T) *T {
        return &v
}

//go:build !appengine

package util

import (
        "unsafe"
)

// BytesToString converts byte slice to string.
func BytesToString(b []byte) string {
        return *(*string)(unsafe.Pointer(&b))
}

// StringToBytes converts string to byte slice.
func StringToBytes(s string) []byte {
        return *(*[]byte)(unsafe.Pointer(
                &struct {
                        string
                        Cap int
                }{s, len(s)},
        ))
}

package redis

import (
        "context"
)

// ScanIterator is used to incrementally iterate over a collection of elements.
type ScanIterator struct {
        cmd *ScanCmd
        pos int
}

// Err returns the last iterator error, if any.
func (it *ScanIterator) Err() error {
        return it.cmd.Err()
}

// Next advances the cursor and returns true if more values can be read.
func (it *ScanIterator) Next(ctx context.Context) bool {
        // Instantly return on errors.
        if it.cmd.Err() != nil {
                return false
        }

        // Advance cursor, check if we are still within range.
        if it.pos < len(it.cmd.page) {
                it.pos++
                return true
        }

        for {
                // Return if there is no more data to fetch.
                if it.cmd.cursor == 0 {
                        return false
                }

                // Fetch next page.
                switch it.cmd.args[0] {
                case "scan", "qscan":
                        it.cmd.args[1] = it.cmd.cursor
                default:
                        it.cmd.args[2] = it.cmd.cursor
                }

                err := it.cmd.process(ctx, it.cmd)
                if err != nil {
                        return false
                }

                it.pos = 1

                // Redis can occasionally return empty page.
                if len(it.cmd.page) > 0 {
                        return true
                }
        }
}

// Val returns the key/field at the current cursor position.
func (it *ScanIterator) Val() string {
        var v string
        if it.cmd.Err() == nil && it.pos > 0 && it.pos <= len(it.cmd.page) {
                v = it.cmd.page[it.pos-1]
        }
        return v
}

package redis

import (
        "context"
        "encoding/json"
        "strings"

        "github.com/redis/go-redis/v9/internal/proto"
        "github.com/redis/go-redis/v9/internal/util"
)

// -------------------------------------------

type JSONCmdable interface {
        JSONArrAppend(ctx context.Context, key, path string, values ...interface{}) *IntSliceCmd
        JSONArrIndex(ctx context.Context, key, path string, value ...interface{}) *IntSliceCmd
        JSONArrIndexWithArgs(ctx context.Context, key, path string, options *JSONArrIndexArgs, value ...interface{}) *IntSliceCmd
        JSONArrInsert(ctx context.Context, key, path string, index int64, values ...interface{}) *IntSliceCmd
        JSONArrLen(ctx context.Context, key, path string) *IntSliceCmd
        JSONArrPop(ctx context.Context, key, path string, index int) *StringSliceCmd
        JSONArrTrim(ctx context.Context, key, path string) *IntSliceCmd
        JSONArrTrimWithArgs(ctx context.Context, key, path string, options *JSONArrTrimArgs) *IntSliceCmd
        JSONClear(ctx context.Context, key, path string) *IntCmd
        JSONDebugMemory(ctx context.Context, key, path string) *IntCmd
        JSONDel(ctx context.Context, key, path string) *IntCmd
        JSONForget(ctx context.Context, key, path string) *IntCmd
        JSONGet(ctx context.Context, key string, paths ...string) *JSONCmd
        JSONGetWithArgs(ctx context.Context, key string, options *JSONGetArgs, paths ...string) *JSONCmd
        JSONMerge(ctx context.Context, key, path string, value string) *StatusCmd
        JSONMSetArgs(ctx context.Context, docs []JSONSetArgs) *StatusCmd
        JSONMSet(ctx context.Context, params ...interface{}) *StatusCmd
        JSONMGet(ctx context.Context, path string, keys ...string) *JSONSliceCmd
        JSONNumIncrBy(ctx context.Context, key, path string, value float64) *JSONCmd
        JSONObjKeys(ctx context.Context, key, path string) *SliceCmd
        JSONObjLen(ctx context.Context, key, path string) *IntPointerSliceCmd
        JSONSet(ctx context.Context, key, path string, value interface{}) *StatusCmd
        JSONSetMode(ctx context.Context, key, path string, value interface{}, mode string) *StatusCmd
        JSONStrAppend(ctx context.Context, key, path, value string) *IntPointerSliceCmd
        JSONStrLen(ctx context.Context, key, path string) *IntPointerSliceCmd
        JSONToggle(ctx context.Context, key, path string) *IntPointerSliceCmd
        JSONType(ctx context.Context, key, path string) *JSONSliceCmd
}

type JSONSetArgs struct {
        Key   string
        Path  string
        Value interface{}
}

type JSONArrIndexArgs struct {
        Start int
        Stop  *int
}

type JSONArrTrimArgs struct {
        Start int
        Stop  *int
}

type JSONCmd struct {
        baseCmd
        val      string
        expanded interface{}
}

var _ Cmder = (*JSONCmd)(nil)

func newJSONCmd(ctx context.Context, args ...interface{}) *JSONCmd {
        return &JSONCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *JSONCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *JSONCmd) SetVal(val string) {
        cmd.val = val
}

func (cmd *JSONCmd) Val() string {
        if len(cmd.val) == 0 && cmd.expanded != nil {
                val, err := json.Marshal(cmd.expanded)
                if err != nil {
                        cmd.SetErr(err)
                        return ""
                }
                return string(val)

        } else {
                return cmd.val
        }
}

func (cmd *JSONCmd) Result() (string, error) {
        return cmd.Val(), cmd.Err()
}

func (cmd *JSONCmd) Expanded() (interface{}, error) {
        if len(cmd.val) != 0 && cmd.expanded == nil {
                err := json.Unmarshal([]byte(cmd.val), &cmd.expanded)
                if err != nil {
                        return nil, err
                }
        }

        return cmd.expanded, nil
}

func (cmd *JSONCmd) readReply(rd *proto.Reader) error {
        // nil response from JSON.(M)GET (cmd.baseCmd.err will be "redis: nil")
        if cmd.baseCmd.Err() == Nil {
                cmd.val = ""
                return Nil
        }

        if readType, err := rd.PeekReplyType(); err != nil {
                return err
        } else if readType == proto.RespArray {

                size, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }

                expanded := make([]interface{}, size)

                for i := 0; i < size; i++ {
                        if expanded[i], err = rd.ReadReply(); err != nil {
                                return err
                        }
                }
                cmd.expanded = expanded

        } else {
                if str, err := rd.ReadString(); err != nil && err != Nil {
                        return err
                } else if str == "" || err == Nil {
                        cmd.val = ""
                } else {
                        cmd.val = str
                }
        }

        return nil
}

// -------------------------------------------

type JSONSliceCmd struct {
        baseCmd
        val []interface{}
}

func NewJSONSliceCmd(ctx context.Context, args ...interface{}) *JSONSliceCmd {
        return &JSONSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *JSONSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *JSONSliceCmd) SetVal(val []interface{}) {
        cmd.val = val
}

func (cmd *JSONSliceCmd) Val() []interface{} {
        return cmd.val
}

func (cmd *JSONSliceCmd) Result() ([]interface{}, error) {
        return cmd.val, cmd.err
}

func (cmd *JSONSliceCmd) readReply(rd *proto.Reader) error {
        if cmd.baseCmd.Err() == Nil {
                cmd.val = nil
                return Nil
        }

        if readType, err := rd.PeekReplyType(); err != nil {
                return err
        } else if readType == proto.RespArray {
                response, err := rd.ReadReply()
                if err != nil {
                        return nil
                } else {
                        cmd.val = response.([]interface{})
                }

        } else {
                n, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }
                cmd.val = make([]interface{}, n)
                for i := 0; i < len(cmd.val); i++ {
                        switch s, err := rd.ReadString(); {
                        case err == Nil:
                                cmd.val[i] = ""
                        case err != nil:
                                return err
                        default:
                                cmd.val[i] = s
                        }
                }
        }
        return nil
}

/*******************************************************************************
*
* IntPointerSliceCmd
* used to represent a RedisJSON response where the result is either an integer or nil
*
*******************************************************************************/

type IntPointerSliceCmd struct {
        baseCmd
        val []*int64
}

// NewIntPointerSliceCmd initialises an IntPointerSliceCmd
func NewIntPointerSliceCmd(ctx context.Context, args ...interface{}) *IntPointerSliceCmd {
        return &IntPointerSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *IntPointerSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *IntPointerSliceCmd) SetVal(val []*int64) {
        cmd.val = val
}

func (cmd *IntPointerSliceCmd) Val() []*int64 {
        return cmd.val
}

func (cmd *IntPointerSliceCmd) Result() ([]*int64, error) {
        return cmd.val, cmd.err
}

func (cmd *IntPointerSliceCmd) readReply(rd *proto.Reader) error {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]*int64, n)

        for i := 0; i < len(cmd.val); i++ {
                val, err := rd.ReadInt()
                if err != nil && err != Nil {
                        return err
                } else if err != Nil {
                        cmd.val[i] = &val
                }
        }

        return nil
}

//------------------------------------------------------------------------------

// JSONArrAppend adds the provided JSON values to the end of the array at the given path.
// For more information, see https://redis.io/commands/json.arrappend
func (c cmdable) JSONArrAppend(ctx context.Context, key, path string, values ...interface{}) *IntSliceCmd {
        args := []interface{}{"JSON.ARRAPPEND", key, path}
        args = append(args, values...)
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONArrIndex searches for the first occurrence of the provided JSON value in the array at the given path.
// For more information, see https://redis.io/commands/json.arrindex
func (c cmdable) JSONArrIndex(ctx context.Context, key, path string, value ...interface{}) *IntSliceCmd {
        args := []interface{}{"JSON.ARRINDEX", key, path}
        args = append(args, value...)
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONArrIndexWithArgs searches for the first occurrence of a JSON value in an array while allowing the start and
// stop options to be provided.
// For more information, see https://redis.io/commands/json.arrindex
func (c cmdable) JSONArrIndexWithArgs(ctx context.Context, key, path string, options *JSONArrIndexArgs, value ...interface{}) *IntSliceCmd {
        args := []interface{}{"JSON.ARRINDEX", key, path}
        args = append(args, value...)

        if options != nil {
                args = append(args, options.Start)
                if options.Stop != nil {
                        args = append(args, *options.Stop)
                }
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONArrInsert inserts the JSON values into the array at the specified path before the index (shifts to the right).
// For more information, see https://redis.io/commands/json.arrinsert
func (c cmdable) JSONArrInsert(ctx context.Context, key, path string, index int64, values ...interface{}) *IntSliceCmd {
        args := []interface{}{"JSON.ARRINSERT", key, path, index}
        args = append(args, values...)
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONArrLen reports the length of the JSON array at the specified path in the given key.
// For more information, see https://redis.io/commands/json.arrlen
func (c cmdable) JSONArrLen(ctx context.Context, key, path string) *IntSliceCmd {
        args := []interface{}{"JSON.ARRLEN", key, path}
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONArrPop removes and returns an element from the specified index in the array.
// For more information, see https://redis.io/commands/json.arrpop
func (c cmdable) JSONArrPop(ctx context.Context, key, path string, index int) *StringSliceCmd {
        args := []interface{}{"JSON.ARRPOP", key, path, index}
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONArrTrim trims an array to contain only the specified inclusive range of elements.
// For more information, see https://redis.io/commands/json.arrtrim
func (c cmdable) JSONArrTrim(ctx context.Context, key, path string) *IntSliceCmd {
        args := []interface{}{"JSON.ARRTRIM", key, path}
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONArrTrimWithArgs trims an array to contain only the specified inclusive range of elements.
// For more information, see https://redis.io/commands/json.arrtrim
func (c cmdable) JSONArrTrimWithArgs(ctx context.Context, key, path string, options *JSONArrTrimArgs) *IntSliceCmd {
        args := []interface{}{"JSON.ARRTRIM", key, path}

        if options != nil {
                args = append(args, options.Start)

                if options.Stop != nil {
                        args = append(args, *options.Stop)
                }
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONClear clears container values (arrays/objects) and sets numeric values to 0.
// For more information, see https://redis.io/commands/json.clear
func (c cmdable) JSONClear(ctx context.Context, key, path string) *IntCmd {
        args := []interface{}{"JSON.CLEAR", key, path}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONDebugMemory reports a value's memory usage in bytes (unimplemented)
// For more information, see https://redis.io/commands/json.debug-memory
func (c cmdable) JSONDebugMemory(ctx context.Context, key, path string) *IntCmd {
        panic("not implemented")
}

// JSONDel deletes a value.
// For more information, see https://redis.io/commands/json.del
func (c cmdable) JSONDel(ctx context.Context, key, path string) *IntCmd {
        args := []interface{}{"JSON.DEL", key, path}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONForget deletes a value.
// For more information, see https://redis.io/commands/json.forget
func (c cmdable) JSONForget(ctx context.Context, key, path string) *IntCmd {
        args := []interface{}{"JSON.FORGET", key, path}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONGet returns the value at path in JSON serialized form. JSON.GET returns an
// array of strings. This function parses out the wrapping array but leaves the
// internal strings unprocessed by default (see Val())
// For more information - https://redis.io/commands/json.get/
func (c cmdable) JSONGet(ctx context.Context, key string, paths ...string) *JSONCmd {
        args := make([]interface{}, len(paths)+2)
        args[0] = "JSON.GET"
        args[1] = key
        for n, path := range paths {
                args[n+2] = path
        }
        cmd := newJSONCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type JSONGetArgs struct {
        Indent  string
        Newline string
        Space   string
}

// JSONGetWithArgs - Retrieves the value of a key from a JSON document.
// This function also allows for specifying additional options such as:
// Indention, NewLine and Space
// For more information - https://redis.io/commands/json.get/
func (c cmdable) JSONGetWithArgs(ctx context.Context, key string, options *JSONGetArgs, paths ...string) *JSONCmd {
        args := []interface{}{"JSON.GET", key}
        if options != nil {
                if options.Indent != "" {
                        args = append(args, "INDENT", options.Indent)
                }
                if options.Newline != "" {
                        args = append(args, "NEWLINE", options.Newline)
                }
                if options.Space != "" {
                        args = append(args, "SPACE", options.Space)
                }
                for _, path := range paths {
                        args = append(args, path)
                }
        }
        cmd := newJSONCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONMerge merges a given JSON value into matching paths.
// For more information, see https://redis.io/commands/json.merge
func (c cmdable) JSONMerge(ctx context.Context, key, path string, value string) *StatusCmd {
        args := []interface{}{"JSON.MERGE", key, path, value}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONMGet returns the values at the specified path from multiple key arguments.
// Note - the arguments are reversed when compared with `JSON.MGET` as we want
// to follow the pattern of having the last argument be variable.
// For more information, see https://redis.io/commands/json.mget
func (c cmdable) JSONMGet(ctx context.Context, path string, keys ...string) *JSONSliceCmd {
        args := make([]interface{}, len(keys)+1)
        args[0] = "JSON.MGET"
        for n, key := range keys {
                args[n+1] = key
        }
        args = append(args, path)
        cmd := NewJSONSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONMSetArgs sets or updates one or more JSON values according to the specified key-path-value triplets.
// For more information, see https://redis.io/commands/json.mset
func (c cmdable) JSONMSetArgs(ctx context.Context, docs []JSONSetArgs) *StatusCmd {
        args := []interface{}{"JSON.MSET"}
        for _, doc := range docs {
                args = append(args, doc.Key, doc.Path, doc.Value)
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) JSONMSet(ctx context.Context, params ...interface{}) *StatusCmd {
        args := []interface{}{"JSON.MSET"}
        args = append(args, params...)
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONNumIncrBy increments the number value stored at the specified path by the provided number.
// For more information, see https://redis.io/docs/latest/commands/json.numincrby/
func (c cmdable) JSONNumIncrBy(ctx context.Context, key, path string, value float64) *JSONCmd {
        args := []interface{}{"JSON.NUMINCRBY", key, path, value}
        cmd := newJSONCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONObjKeys returns the keys in the object that's referenced by the specified path.
// For more information, see https://redis.io/commands/json.objkeys
func (c cmdable) JSONObjKeys(ctx context.Context, key, path string) *SliceCmd {
        args := []interface{}{"JSON.OBJKEYS", key, path}
        cmd := NewSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONObjLen reports the number of keys in the JSON object at the specified path in the given key.
// For more information, see https://redis.io/commands/json.objlen
func (c cmdable) JSONObjLen(ctx context.Context, key, path string) *IntPointerSliceCmd {
        args := []interface{}{"JSON.OBJLEN", key, path}
        cmd := NewIntPointerSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONSet sets the JSON value at the given path in the given key. The value must be something that
// can be marshaled to JSON (using encoding/JSON) unless the argument is a string or a []byte when we assume that
// it can be passed directly as JSON.
// For more information, see https://redis.io/commands/json.set
func (c cmdable) JSONSet(ctx context.Context, key, path string, value interface{}) *StatusCmd {
        return c.JSONSetMode(ctx, key, path, value, "")
}

// JSONSetMode sets the JSON value at the given path in the given key and allows the mode to be set
// (the mode value must be "XX" or "NX"). The value must be something that can be marshaled to JSON (using encoding/JSON) unless
// the argument is a string or []byte when we assume that it can be passed directly as JSON.
// For more information, see https://redis.io/commands/json.set
func (c cmdable) JSONSetMode(ctx context.Context, key, path string, value interface{}, mode string) *StatusCmd {
        var bytes []byte
        var err error
        switch v := value.(type) {
        case string:
                bytes = []byte(v)
        case []byte:
                bytes = v
        default:
                bytes, err = json.Marshal(v)
        }
        args := []interface{}{"JSON.SET", key, path, util.BytesToString(bytes)}
        if mode != "" {
                switch strings.ToUpper(mode) {
                case "XX", "NX":
                        args = append(args, strings.ToUpper(mode))

                default:
                        panic("redis: JSON.SET mode must be NX or XX")
                }
        }
        cmd := NewStatusCmd(ctx, args...)
        if err != nil {
                cmd.SetErr(err)
        } else {
                _ = c(ctx, cmd)
        }
        return cmd
}

// JSONStrAppend appends the JSON-string values to the string at the specified path.
// For more information, see https://redis.io/commands/json.strappend
func (c cmdable) JSONStrAppend(ctx context.Context, key, path, value string) *IntPointerSliceCmd {
        args := []interface{}{"JSON.STRAPPEND", key, path, value}
        cmd := NewIntPointerSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONStrLen reports the length of the JSON String at the specified path in the given key.
// For more information, see https://redis.io/commands/json.strlen
func (c cmdable) JSONStrLen(ctx context.Context, key, path string) *IntPointerSliceCmd {
        args := []interface{}{"JSON.STRLEN", key, path}
        cmd := NewIntPointerSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONToggle toggles a Boolean value stored at the specified path.
// For more information, see https://redis.io/commands/json.toggle
func (c cmdable) JSONToggle(ctx context.Context, key, path string) *IntPointerSliceCmd {
        args := []interface{}{"JSON.TOGGLE", key, path}
        cmd := NewIntPointerSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// JSONType reports the type of JSON value at the specified path.
// For more information, see https://redis.io/commands/json.type
func (c cmdable) JSONType(ctx context.Context, key, path string) *JSONSliceCmd {
        args := []interface{}{"JSON.TYPE", key, path}
        cmd := NewJSONSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "strings"
        "time"
)

type ListCmdable interface {
        BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd
        BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *KeyValuesCmd
        BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd
        BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd
        LIndex(ctx context.Context, key string, index int64) *StringCmd
        LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd
        LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd
        LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd
        LLen(ctx context.Context, key string) *IntCmd
        LMPop(ctx context.Context, direction string, count int64, keys ...string) *KeyValuesCmd
        LPop(ctx context.Context, key string) *StringCmd
        LPopCount(ctx context.Context, key string, count int) *StringSliceCmd
        LPos(ctx context.Context, key string, value string, args LPosArgs) *IntCmd
        LPosCount(ctx context.Context, key string, value string, count int64, args LPosArgs) *IntSliceCmd
        LPush(ctx context.Context, key string, values ...interface{}) *IntCmd
        LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd
        LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
        LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd
        LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd
        LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd
        RPop(ctx context.Context, key string) *StringCmd
        RPopCount(ctx context.Context, key string, count int) *StringSliceCmd
        RPopLPush(ctx context.Context, source, destination string) *StringCmd
        RPush(ctx context.Context, key string, values ...interface{}) *IntCmd
        RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd
        LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd
        BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *StringCmd
}

func (c cmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {
        args := make([]interface{}, 1+len(keys)+1)
        args[0] = "blpop"
        for i, key := range keys {
                args[1+i] = key
        }
        args[len(args)-1] = formatSec(ctx, timeout)
        cmd := NewStringSliceCmd(ctx, args...)
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *KeyValuesCmd {
        args := make([]interface{}, 3+len(keys), 6+len(keys))
        args[0] = "blmpop"
        args[1] = formatSec(ctx, timeout)
        args[2] = len(keys)
        for i, key := range keys {
                args[3+i] = key
        }
        args = append(args, strings.ToLower(direction), "count", count)
        cmd := NewKeyValuesCmd(ctx, args...)
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {
        args := make([]interface{}, 1+len(keys)+1)
        args[0] = "brpop"
        for i, key := range keys {
                args[1+i] = key
        }
        args[len(keys)+1] = formatSec(ctx, timeout)
        cmd := NewStringSliceCmd(ctx, args...)
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd {
        cmd := NewStringCmd(
                ctx,
                "brpoplpush",
                source,
                destination,
                formatSec(ctx, timeout),
        )
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LIndex(ctx context.Context, key string, index int64) *StringCmd {
        cmd := NewStringCmd(ctx, "lindex", key, index)
        _ = c(ctx, cmd)
        return cmd
}

// LMPop Pops one or more elements from the first non-empty list key from the list of provided key names.
// direction: left or right, count: > 0
// example: client.LMPop(ctx, "left", 3, "key1", "key2")
func (c cmdable) LMPop(ctx context.Context, direction string, count int64, keys ...string) *KeyValuesCmd {
        args := make([]interface{}, 2+len(keys), 5+len(keys))
        args[0] = "lmpop"
        args[1] = len(keys)
        for i, key := range keys {
                args[2+i] = key
        }
        args = append(args, strings.ToLower(direction), "count", count)
        cmd := NewKeyValuesCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd {
        cmd := NewIntCmd(ctx, "linsert", key, op, pivot, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd {
        cmd := NewIntCmd(ctx, "linsert", key, "before", pivot, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd {
        cmd := NewIntCmd(ctx, "linsert", key, "after", pivot, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LLen(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "llen", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LPop(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "lpop", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LPopCount(ctx context.Context, key string, count int) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "lpop", key, count)
        _ = c(ctx, cmd)
        return cmd
}

type LPosArgs struct {
        Rank, MaxLen int64
}

func (c cmdable) LPos(ctx context.Context, key string, value string, a LPosArgs) *IntCmd {
        args := []interface{}{"lpos", key, value}
        if a.Rank != 0 {
                args = append(args, "rank", a.Rank)
        }
        if a.MaxLen != 0 {
                args = append(args, "maxlen", a.MaxLen)
        }

        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LPosCount(ctx context.Context, key string, value string, count int64, a LPosArgs) *IntSliceCmd {
        args := []interface{}{"lpos", key, value, "count", count}
        if a.Rank != 0 {
                args = append(args, "rank", a.Rank)
        }
        if a.MaxLen != 0 {
                args = append(args, "maxlen", a.MaxLen)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LPush(ctx context.Context, key string, values ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(values))
        args[0] = "lpush"
        args[1] = key
        args = appendArgs(args, values)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(values))
        args[0] = "lpushx"
        args[1] = key
        args = appendArgs(args, values)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
        cmd := NewStringSliceCmd(
                ctx,
                "lrange",
                key,
                start,
                stop,
        )
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd {
        cmd := NewIntCmd(ctx, "lrem", key, count, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd {
        cmd := NewStatusCmd(ctx, "lset", key, index, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd {
        cmd := NewStatusCmd(
                ctx,
                "ltrim",
                key,
                start,
                stop,
        )
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) RPop(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "rpop", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) RPopCount(ctx context.Context, key string, count int) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "rpop", key, count)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) RPopLPush(ctx context.Context, source, destination string) *StringCmd {
        cmd := NewStringCmd(ctx, "rpoplpush", source, destination)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) RPush(ctx context.Context, key string, values ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(values))
        args[0] = "rpush"
        args[1] = key
        args = appendArgs(args, values)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(values))
        args[0] = "rpushx"
        args[1] = key
        args = appendArgs(args, values)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd {
        cmd := NewStringCmd(ctx, "lmove", source, destination, srcpos, destpos)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) BLMove(
        ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration,
) *StringCmd {
        cmd := NewStringCmd(ctx, "blmove", source, destination, srcpos, destpos, formatSec(ctx, timeout))
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "crypto/tls"
        "errors"
        "fmt"
        "net"
        "net/url"
        "runtime"
        "sort"
        "strconv"
        "strings"
        "time"

        "github.com/redis/go-redis/v9/auth"
        "github.com/redis/go-redis/v9/internal/pool"
)

// Limiter is the interface of a rate limiter or a circuit breaker.
type Limiter interface {
        // Allow returns nil if operation is allowed or an error otherwise.
        // If operation is allowed client must ReportResult of the operation
        // whether it is a success or a failure.
        Allow() error
        // ReportResult reports the result of the previously allowed operation.
        // nil indicates a success, non-nil error usually indicates a failure.
        ReportResult(result error)
}

// Options keeps the settings to set up redis connection.
type Options struct {

        // Network type, either tcp or unix.
        //
        // default: is tcp.
        Network string

        // Addr is the address formated as host:port
        Addr string

        // ClientName will execute the `CLIENT SETNAME ClientName` command for each conn.
        ClientName string

        // Dialer creates new network connection and has priority over
        // Network and Addr options.
        Dialer func(ctx context.Context, network, addr string) (net.Conn, error)

        // Hook that is called when new connection is established.
        OnConnect func(ctx context.Context, cn *Conn) error

        // Protocol 2 or 3. Use the version to negotiate RESP version with redis-server.
        //
        // default: 3.
        Protocol int

        // Username is used to authenticate the current connection
        // with one of the connections defined in the ACL list when connecting
        // to a Redis 6.0 instance, or greater, that is using the Redis ACL system.
        Username string

        // Password is an optional password. Must match the password specified in the
        // `requirepass` server configuration option (if connecting to a Redis 5.0 instance, or lower),
        // or the User Password when connecting to a Redis 6.0 instance, or greater,
        // that is using the Redis ACL system.
        Password string

        // CredentialsProvider allows the username and password to be updated
        // before reconnecting. It should return the current username and password.
        CredentialsProvider func() (username string, password string)

        // CredentialsProviderContext is an enhanced parameter of CredentialsProvider,
        // done to maintain API compatibility. In the future,
        // there might be a merge between CredentialsProviderContext and CredentialsProvider.
        // There will be a conflict between them; if CredentialsProviderContext exists, we will ignore CredentialsProvider.
        CredentialsProviderContext func(ctx context.Context) (username string, password string, err error)

        // StreamingCredentialsProvider is used to retrieve the credentials
        // for the connection from an external source. Those credentials may change
        // during the connection lifetime. This is useful for managed identity
        // scenarios where the credentials are retrieved from an external source.
        //
        // Currently, this is a placeholder for the future implementation.
        StreamingCredentialsProvider auth.StreamingCredentialsProvider

        // DB is the database to be selected after connecting to the server.
        DB int

        // MaxRetries is the maximum number of retries before giving up.
        // -1 (not 0) disables retries.
        //
        // default: 3 retries
        MaxRetries int

        // MinRetryBackoff is the minimum backoff between each retry.
        // -1 disables backoff.
        //
        // default: 8 milliseconds
        MinRetryBackoff time.Duration

        // MaxRetryBackoff is the maximum backoff between each retry.
        // -1 disables backoff.
        // default: 512 milliseconds;
        MaxRetryBackoff time.Duration

        // DialTimeout for establishing new connections.
        //
        // default: 5 seconds
        DialTimeout time.Duration

        // ReadTimeout for socket reads. If reached, commands will fail
        // with a timeout instead of blocking. Supported values:
        //
        //        - `-1` - no timeout (block indefinitely).
        //        - `-2` - disables SetReadDeadline calls completely.
        //
        // default: 3 seconds
        ReadTimeout time.Duration

        // WriteTimeout for socket writes. If reached, commands will fail
        // with a timeout instead of blocking.  Supported values:
        //
        //        - `-1` - no timeout (block indefinitely).
        //        - `-2` - disables SetWriteDeadline calls completely.
        //
        // default: 3 seconds
        WriteTimeout time.Duration

        // ContextTimeoutEnabled controls whether the client respects context timeouts and deadlines.
        // See https://redis.uptrace.dev/guide/go-redis-debugging.html#timeouts
        ContextTimeoutEnabled bool

        // PoolFIFO type of connection pool.
        //
        //        - true for FIFO pool
        //        - false for LIFO pool.
        //
        // Note that FIFO has slightly higher overhead compared to LIFO,
        // but it helps closing idle connections faster reducing the pool size.
        PoolFIFO bool

        // PoolSize is the base number of socket connections.
        // Default is 10 connections per every available CPU as reported by runtime.GOMAXPROCS.
        // If there is not enough connections in the pool, new connections will be allocated in excess of PoolSize,
        // you can limit it through MaxActiveConns
        //
        // default: 10 * runtime.GOMAXPROCS(0)
        PoolSize int

        // PoolTimeout is the amount of time client waits for connection if all connections
        // are busy before returning an error.
        //
        // default: ReadTimeout + 1 second
        PoolTimeout time.Duration

        // MinIdleConns is the minimum number of idle connections which is useful when establishing
        // new connection is slow. The idle connections are not closed by default.
        //
        // default: 0
        MinIdleConns int

        // MaxIdleConns is the maximum number of idle connections.
        // The idle connections are not closed by default.
        //
        // default: 0
        MaxIdleConns int

        // MaxActiveConns is the maximum number of connections allocated by the pool at a given time.
        // When zero, there is no limit on the number of connections in the pool.
        // If the pool is full, the next call to Get() will block until a connection is released.
        MaxActiveConns int

        // ConnMaxIdleTime is the maximum amount of time a connection may be idle.
        // Should be less than server's timeout.
        //
        // Expired connections may be closed lazily before reuse.
        // If d <= 0, connections are not closed due to a connection's idle time.
        // -1 disables idle timeout check.
        //
        // default: 30 minutes
        ConnMaxIdleTime time.Duration

        // ConnMaxLifetime is the maximum amount of time a connection may be reused.
        //
        // Expired connections may be closed lazily before reuse.
        // If <= 0, connections are not closed due to a connection's age.
        //
        // default: 0
        ConnMaxLifetime time.Duration

        // TLSConfig to use. When set, TLS will be negotiated.
        TLSConfig *tls.Config

        // Limiter interface used to implement circuit breaker or rate limiter.
        Limiter Limiter

        // readOnly enables read only queries on slave/follower nodes.
        readOnly bool

        // DisableIndentity - Disable set-lib on connect.
        //
        // default: false
        //
        // Deprecated: Use DisableIdentity instead.
        DisableIndentity bool

        // DisableIdentity is used to disable CLIENT SETINFO command on connect.
        //
        // default: false
        DisableIdentity bool

        // Add suffix to client name. Default is empty.
        // IdentitySuffix - add suffix to client name.
        IdentitySuffix string

        // UnstableResp3 enables Unstable mode for Redis Search module with RESP3.
        // When unstable mode is enabled, the client will use RESP3 protocol and only be able to use RawResult
        UnstableResp3 bool
}

func (opt *Options) init() {
        if opt.Addr == "" {
                opt.Addr = "localhost:6379"
        }
        if opt.Network == "" {
                if strings.HasPrefix(opt.Addr, "/") {
                        opt.Network = "unix"
                } else {
                        opt.Network = "tcp"
                }
        }
        if opt.Protocol < 2 {
                opt.Protocol = 3
        }
        if opt.DialTimeout == 0 {
                opt.DialTimeout = 5 * time.Second
        }
        if opt.Dialer == nil {
                opt.Dialer = NewDialer(opt)
        }
        if opt.PoolSize == 0 {
                opt.PoolSize = 10 * runtime.GOMAXPROCS(0)
        }
        switch opt.ReadTimeout {
        case -2:
                opt.ReadTimeout = -1
        case -1:
                opt.ReadTimeout = 0
        case 0:
                opt.ReadTimeout = 3 * time.Second
        }
        switch opt.WriteTimeout {
        case -2:
                opt.WriteTimeout = -1
        case -1:
                opt.WriteTimeout = 0
        case 0:
                opt.WriteTimeout = opt.ReadTimeout
        }
        if opt.PoolTimeout == 0 {
                if opt.ReadTimeout > 0 {
                        opt.PoolTimeout = opt.ReadTimeout + time.Second
                } else {
                        opt.PoolTimeout = 30 * time.Second
                }
        }
        if opt.ConnMaxIdleTime == 0 {
                opt.ConnMaxIdleTime = 30 * time.Minute
        }

        switch opt.MaxRetries {
        case -1:
                opt.MaxRetries = 0
        case 0:
                opt.MaxRetries = 3
        }
        switch opt.MinRetryBackoff {
        case -1:
                opt.MinRetryBackoff = 0
        case 0:
                opt.MinRetryBackoff = 8 * time.Millisecond
        }
        switch opt.MaxRetryBackoff {
        case -1:
                opt.MaxRetryBackoff = 0
        case 0:
                opt.MaxRetryBackoff = 512 * time.Millisecond
        }
}

func (opt *Options) clone() *Options {
        clone := *opt
        return &clone
}

// NewDialer returns a function that will be used as the default dialer
// when none is specified in Options.Dialer.
func NewDialer(opt *Options) func(context.Context, string, string) (net.Conn, error) {
        return func(ctx context.Context, network, addr string) (net.Conn, error) {
                netDialer := &net.Dialer{
                        Timeout:   opt.DialTimeout,
                        KeepAlive: 5 * time.Minute,
                }
                if opt.TLSConfig == nil {
                        return netDialer.DialContext(ctx, network, addr)
                }
                return tls.DialWithDialer(netDialer, network, addr, opt.TLSConfig)
        }
}

// ParseURL parses a URL into Options that can be used to connect to Redis.
// Scheme is required.
// There are two connection types: by tcp socket and by unix socket.
// Tcp connection:
//
//        redis://<user>:<password>@<host>:<port>/<db_number>
//
// Unix connection:
//
//        unix://<user>:<password>@</path/to/redis.sock>?db=<db_number>
//
// Most Option fields can be set using query parameters, with the following restrictions:
//   - field names are mapped using snake-case conversion: to set MaxRetries, use max_retries
//   - only scalar type fields are supported (bool, int, time.Duration)
//   - for time.Duration fields, values must be a valid input for time.ParseDuration();
//     additionally a plain integer as value (i.e. without unit) is interpreted as seconds
//   - to disable a duration field, use value less than or equal to 0; to use the default
//     value, leave the value blank or remove the parameter
//   - only the last value is interpreted if a parameter is given multiple times
//   - fields "network", "addr", "username" and "password" can only be set using other
//     URL attributes (scheme, host, userinfo, resp.), query parameters using these
//     names will be treated as unknown parameters
//   - unknown parameter names will result in an error
//   - use "skip_verify=true" to ignore TLS certificate validation
//
// Examples:
//
//        redis://user:password@localhost:6789/3?dial_timeout=3&db=1&read_timeout=6s&max_retries=2
//        is equivalent to:
//        &Options{
//                Network:     "tcp",
//                Addr:        "localhost:6789",
//                DB:          1,               // path "/3" was overridden by "&db=1"
//                DialTimeout: 3 * time.Second, // no time unit = seconds
//                ReadTimeout: 6 * time.Second,
//                MaxRetries:  2,
//        }
func ParseURL(redisURL string) (*Options, error) {
        u, err := url.Parse(redisURL)
        if err != nil {
                return nil, err
        }

        switch u.Scheme {
        case "redis", "rediss":
                return setupTCPConn(u)
        case "unix":
                return setupUnixConn(u)
        default:
                return nil, fmt.Errorf("redis: invalid URL scheme: %s", u.Scheme)
        }
}

func setupTCPConn(u *url.URL) (*Options, error) {
        o := &Options{Network: "tcp"}

        o.Username, o.Password = getUserPassword(u)

        h, p := getHostPortWithDefaults(u)
        o.Addr = net.JoinHostPort(h, p)

        f := strings.FieldsFunc(u.Path, func(r rune) bool {
                return r == '/'
        })
        switch len(f) {
        case 0:
                o.DB = 0
        case 1:
                var err error
                if o.DB, err = strconv.Atoi(f[0]); err != nil {
                        return nil, fmt.Errorf("redis: invalid database number: %q", f[0])
                }
        default:
                return nil, fmt.Errorf("redis: invalid URL path: %s", u.Path)
        }

        if u.Scheme == "rediss" {
                o.TLSConfig = &tls.Config{
                        ServerName: h,
                        MinVersion: tls.VersionTLS12,
                }
        }

        return setupConnParams(u, o)
}

// getHostPortWithDefaults is a helper function that splits the url into
// a host and a port. If the host is missing, it defaults to localhost
// and if the port is missing, it defaults to 6379.
func getHostPortWithDefaults(u *url.URL) (string, string) {
        host, port, err := net.SplitHostPort(u.Host)
        if err != nil {
                host = u.Host
        }
        if host == "" {
                host = "localhost"
        }
        if port == "" {
                port = "6379"
        }
        return host, port
}

func setupUnixConn(u *url.URL) (*Options, error) {
        o := &Options{
                Network: "unix",
        }

        if strings.TrimSpace(u.Path) == "" { // path is required with unix connection
                return nil, errors.New("redis: empty unix socket path")
        }
        o.Addr = u.Path
        o.Username, o.Password = getUserPassword(u)
        return setupConnParams(u, o)
}

type queryOptions struct {
        q   url.Values
        err error
}

func (o *queryOptions) has(name string) bool {
        return len(o.q[name]) > 0
}

func (o *queryOptions) string(name string) string {
        vs := o.q[name]
        if len(vs) == 0 {
                return ""
        }
        delete(o.q, name) // enable detection of unknown parameters
        return vs[len(vs)-1]
}

func (o *queryOptions) strings(name string) []string {
        vs := o.q[name]
        delete(o.q, name)
        return vs
}

func (o *queryOptions) int(name string) int {
        s := o.string(name)
        if s == "" {
                return 0
        }
        i, err := strconv.Atoi(s)
        if err == nil {
                return i
        }
        if o.err == nil {
                o.err = fmt.Errorf("redis: invalid %s number: %s", name, err)
        }
        return 0
}

func (o *queryOptions) duration(name string) time.Duration {
        s := o.string(name)
        if s == "" {
                return 0
        }
        // try plain number first
        if i, err := strconv.Atoi(s); err == nil {
                if i <= 0 {
                        // disable timeouts
                        return -1
                }
                return time.Duration(i) * time.Second
        }
        dur, err := time.ParseDuration(s)
        if err == nil {
                return dur
        }
        if o.err == nil {
                o.err = fmt.Errorf("redis: invalid %s duration: %w", name, err)
        }
        return 0
}

func (o *queryOptions) bool(name string) bool {
        switch s := o.string(name); s {
        case "true", "1":
                return true
        case "false", "0", "":
                return false
        default:
                if o.err == nil {
                        o.err = fmt.Errorf("redis: invalid %s boolean: expected true/false/1/0 or an empty string, got %q", name, s)
                }
                return false
        }
}

func (o *queryOptions) remaining() []string {
        if len(o.q) == 0 {
                return nil
        }
        keys := make([]string, 0, len(o.q))
        for k := range o.q {
                keys = append(keys, k)
        }
        sort.Strings(keys)
        return keys
}

// setupConnParams converts query parameters in u to option value in o.
func setupConnParams(u *url.URL, o *Options) (*Options, error) {
        q := queryOptions{q: u.Query()}

        // compat: a future major release may use q.int("db")
        if tmp := q.string("db"); tmp != "" {
                db, err := strconv.Atoi(tmp)
                if err != nil {
                        return nil, fmt.Errorf("redis: invalid database number: %w", err)
                }
                o.DB = db
        }

        o.Protocol = q.int("protocol")
        o.ClientName = q.string("client_name")
        o.MaxRetries = q.int("max_retries")
        o.MinRetryBackoff = q.duration("min_retry_backoff")
        o.MaxRetryBackoff = q.duration("max_retry_backoff")
        o.DialTimeout = q.duration("dial_timeout")
        o.ReadTimeout = q.duration("read_timeout")
        o.WriteTimeout = q.duration("write_timeout")
        o.PoolFIFO = q.bool("pool_fifo")
        o.PoolSize = q.int("pool_size")
        o.PoolTimeout = q.duration("pool_timeout")
        o.MinIdleConns = q.int("min_idle_conns")
        o.MaxIdleConns = q.int("max_idle_conns")
        o.MaxActiveConns = q.int("max_active_conns")
        if q.has("conn_max_idle_time") {
                o.ConnMaxIdleTime = q.duration("conn_max_idle_time")
        } else {
                o.ConnMaxIdleTime = q.duration("idle_timeout")
        }
        if q.has("conn_max_lifetime") {
                o.ConnMaxLifetime = q.duration("conn_max_lifetime")
        } else {
                o.ConnMaxLifetime = q.duration("max_conn_age")
        }
        if q.err != nil {
                return nil, q.err
        }
        if o.TLSConfig != nil && q.has("skip_verify") {
                o.TLSConfig.InsecureSkipVerify = q.bool("skip_verify")
        }

        // any parameters left?
        if r := q.remaining(); len(r) > 0 {
                return nil, fmt.Errorf("redis: unexpected option: %s", strings.Join(r, ", "))
        }

        return o, nil
}

func getUserPassword(u *url.URL) (string, string) {
        var user, password string
        if u.User != nil {
                user = u.User.Username()
                if p, ok := u.User.Password(); ok {
                        password = p
                }
        }
        return user, password
}

func newConnPool(
        opt *Options,
        dialer func(ctx context.Context, network, addr string) (net.Conn, error),
) *pool.ConnPool {
        return pool.NewConnPool(&pool.Options{
                Dialer: func(ctx context.Context) (net.Conn, error) {
                        return dialer(ctx, opt.Network, opt.Addr)
                },
                PoolFIFO:        opt.PoolFIFO,
                PoolSize:        opt.PoolSize,
                PoolTimeout:     opt.PoolTimeout,
                DialTimeout:     opt.DialTimeout,
                MinIdleConns:    opt.MinIdleConns,
                MaxIdleConns:    opt.MaxIdleConns,
                MaxActiveConns:  opt.MaxActiveConns,
                ConnMaxIdleTime: opt.ConnMaxIdleTime,
                ConnMaxLifetime: opt.ConnMaxLifetime,
        })
}

package redis

import (
        "context"
        "crypto/tls"
        "fmt"
        "math"
        "net"
        "net/url"
        "runtime"
        "sort"
        "strings"
        "sync"
        "sync/atomic"
        "time"

        "github.com/redis/go-redis/v9/auth"
        "github.com/redis/go-redis/v9/internal"
        "github.com/redis/go-redis/v9/internal/hashtag"
        "github.com/redis/go-redis/v9/internal/pool"
        "github.com/redis/go-redis/v9/internal/proto"
        "github.com/redis/go-redis/v9/internal/rand"
)

const (
        minLatencyMeasurementInterval = 10 * time.Second
)

var errClusterNoNodes = fmt.Errorf("redis: cluster has no nodes")

// ClusterOptions are used to configure a cluster client and should be
// passed to NewClusterClient.
type ClusterOptions struct {
        // A seed list of host:port addresses of cluster nodes.
        Addrs []string

        // ClientName will execute the `CLIENT SETNAME ClientName` command for each conn.
        ClientName string

        // NewClient creates a cluster node client with provided name and options.
        NewClient func(opt *Options) *Client

        // The maximum number of retries before giving up. Command is retried
        // on network errors and MOVED/ASK redirects.
        // Default is 3 retries.
        MaxRedirects int

        // Enables read-only commands on slave nodes.
        ReadOnly bool
        // Allows routing read-only commands to the closest master or slave node.
        // It automatically enables ReadOnly.
        RouteByLatency bool
        // Allows routing read-only commands to the random master or slave node.
        // It automatically enables ReadOnly.
        RouteRandomly bool

        // Optional function that returns cluster slots information.
        // It is useful to manually create cluster of standalone Redis servers
        // and load-balance read/write operations between master and slaves.
        // It can use service like ZooKeeper to maintain configuration information
        // and Cluster.ReloadState to manually trigger state reloading.
        ClusterSlots func(context.Context) ([]ClusterSlot, error)

        // Following options are copied from Options struct.

        Dialer func(ctx context.Context, network, addr string) (net.Conn, error)

        OnConnect func(ctx context.Context, cn *Conn) error

        Protocol                     int
        Username                     string
        Password                     string
        CredentialsProvider          func() (username string, password string)
        CredentialsProviderContext   func(ctx context.Context) (username string, password string, err error)
        StreamingCredentialsProvider auth.StreamingCredentialsProvider

        MaxRetries      int
        MinRetryBackoff time.Duration
        MaxRetryBackoff time.Duration

        DialTimeout           time.Duration
        ReadTimeout           time.Duration
        WriteTimeout          time.Duration
        ContextTimeoutEnabled bool

        PoolFIFO        bool
        PoolSize        int // applies per cluster node and not for the whole cluster
        PoolTimeout     time.Duration
        MinIdleConns    int
        MaxIdleConns    int
        MaxActiveConns  int // applies per cluster node and not for the whole cluster
        ConnMaxIdleTime time.Duration
        ConnMaxLifetime time.Duration

        TLSConfig *tls.Config

        // DisableIndentity - Disable set-lib on connect.
        //
        // default: false
        //
        // Deprecated: Use DisableIdentity instead.
        DisableIndentity bool

        // DisableIdentity is used to disable CLIENT SETINFO command on connect.
        //
        // default: false
        DisableIdentity bool

        IdentitySuffix string // Add suffix to client name. Default is empty.

        // UnstableResp3 enables Unstable mode for Redis Search module with RESP3.
        UnstableResp3 bool
}

func (opt *ClusterOptions) init() {
        switch opt.MaxRedirects {
        case -1:
                opt.MaxRedirects = 0
        case 0:
                opt.MaxRedirects = 3
        }

        if opt.RouteByLatency || opt.RouteRandomly {
                opt.ReadOnly = true
        }

        if opt.PoolSize == 0 {
                opt.PoolSize = 5 * runtime.GOMAXPROCS(0)
        }

        switch opt.ReadTimeout {
        case -1:
                opt.ReadTimeout = 0
        case 0:
                opt.ReadTimeout = 3 * time.Second
        }
        switch opt.WriteTimeout {
        case -1:
                opt.WriteTimeout = 0
        case 0:
                opt.WriteTimeout = opt.ReadTimeout
        }

        if opt.MaxRetries == 0 {
                opt.MaxRetries = -1
        }
        switch opt.MinRetryBackoff {
        case -1:
                opt.MinRetryBackoff = 0
        case 0:
                opt.MinRetryBackoff = 8 * time.Millisecond
        }
        switch opt.MaxRetryBackoff {
        case -1:
                opt.MaxRetryBackoff = 0
        case 0:
                opt.MaxRetryBackoff = 512 * time.Millisecond
        }

        if opt.NewClient == nil {
                opt.NewClient = NewClient
        }
}

// ParseClusterURL parses a URL into ClusterOptions that can be used to connect to Redis.
// The URL must be in the form:
//
//        redis://<user>:<password>@<host>:<port>
//        or
//        rediss://<user>:<password>@<host>:<port>
//
// To add additional addresses, specify the query parameter, "addr" one or more times. e.g:
//
//        redis://<user>:<password>@<host>:<port>?addr=<host2>:<port2>&addr=<host3>:<port3>
//        or
//        rediss://<user>:<password>@<host>:<port>?addr=<host2>:<port2>&addr=<host3>:<port3>
//
// Most Option fields can be set using query parameters, with the following restrictions:
//   - field names are mapped using snake-case conversion: to set MaxRetries, use max_retries
//   - only scalar type fields are supported (bool, int, time.Duration)
//   - for time.Duration fields, values must be a valid input for time.ParseDuration();
//     additionally a plain integer as value (i.e. without unit) is interpreted as seconds
//   - to disable a duration field, use value less than or equal to 0; to use the default
//     value, leave the value blank or remove the parameter
//   - only the last value is interpreted if a parameter is given multiple times
//   - fields "network", "addr", "username" and "password" can only be set using other
//     URL attributes (scheme, host, userinfo, resp.), query parameters using these
//     names will be treated as unknown parameters
//   - unknown parameter names will result in an error
//
// Example:
//
//        redis://user:password@localhost:6789?dial_timeout=3&read_timeout=6s&addr=localhost:6790&addr=localhost:6791
//        is equivalent to:
//        &ClusterOptions{
//                Addr:        ["localhost:6789", "localhost:6790", "localhost:6791"]
//                DialTimeout: 3 * time.Second, // no time unit = seconds
//                ReadTimeout: 6 * time.Second,
//        }
func ParseClusterURL(redisURL string) (*ClusterOptions, error) {
        o := &ClusterOptions{}

        u, err := url.Parse(redisURL)
        if err != nil {
                return nil, err
        }

        // add base URL to the array of addresses
        // more addresses may be added through the URL params
        h, p := getHostPortWithDefaults(u)
        o.Addrs = append(o.Addrs, net.JoinHostPort(h, p))

        // setup username, password, and other configurations
        o, err = setupClusterConn(u, h, o)
        if err != nil {
                return nil, err
        }

        return o, nil
}

// setupClusterConn gets the username and password from the URL and the query parameters.
func setupClusterConn(u *url.URL, host string, o *ClusterOptions) (*ClusterOptions, error) {
        switch u.Scheme {
        case "rediss":
                o.TLSConfig = &tls.Config{ServerName: host}
                fallthrough
        case "redis":
                o.Username, o.Password = getUserPassword(u)
        default:
                return nil, fmt.Errorf("redis: invalid URL scheme: %s", u.Scheme)
        }

        // retrieve the configuration from the query parameters
        o, err := setupClusterQueryParams(u, o)
        if err != nil {
                return nil, err
        }

        return o, nil
}

// setupClusterQueryParams converts query parameters in u to option value in o.
func setupClusterQueryParams(u *url.URL, o *ClusterOptions) (*ClusterOptions, error) {
        q := queryOptions{q: u.Query()}

        o.Protocol = q.int("protocol")
        o.ClientName = q.string("client_name")
        o.MaxRedirects = q.int("max_redirects")
        o.ReadOnly = q.bool("read_only")
        o.RouteByLatency = q.bool("route_by_latency")
        o.RouteRandomly = q.bool("route_randomly")
        o.MaxRetries = q.int("max_retries")
        o.MinRetryBackoff = q.duration("min_retry_backoff")
        o.MaxRetryBackoff = q.duration("max_retry_backoff")
        o.DialTimeout = q.duration("dial_timeout")
        o.ReadTimeout = q.duration("read_timeout")
        o.WriteTimeout = q.duration("write_timeout")
        o.PoolFIFO = q.bool("pool_fifo")
        o.PoolSize = q.int("pool_size")
        o.MinIdleConns = q.int("min_idle_conns")
        o.MaxIdleConns = q.int("max_idle_conns")
        o.MaxActiveConns = q.int("max_active_conns")
        o.PoolTimeout = q.duration("pool_timeout")
        o.ConnMaxLifetime = q.duration("conn_max_lifetime")
        o.ConnMaxIdleTime = q.duration("conn_max_idle_time")

        if q.err != nil {
                return nil, q.err
        }

        // addr can be specified as many times as needed
        addrs := q.strings("addr")
        for _, addr := range addrs {
                h, p, err := net.SplitHostPort(addr)
                if err != nil || h == "" || p == "" {
                        return nil, fmt.Errorf("redis: unable to parse addr param: %s", addr)
                }

                o.Addrs = append(o.Addrs, net.JoinHostPort(h, p))
        }

        // any parameters left?
        if r := q.remaining(); len(r) > 0 {
                return nil, fmt.Errorf("redis: unexpected option: %s", strings.Join(r, ", "))
        }

        return o, nil
}

func (opt *ClusterOptions) clientOptions() *Options {
        return &Options{
                ClientName: opt.ClientName,
                Dialer:     opt.Dialer,
                OnConnect:  opt.OnConnect,

                Protocol:                     opt.Protocol,
                Username:                     opt.Username,
                Password:                     opt.Password,
                CredentialsProvider:          opt.CredentialsProvider,
                CredentialsProviderContext:   opt.CredentialsProviderContext,
                StreamingCredentialsProvider: opt.StreamingCredentialsProvider,

                MaxRetries:      opt.MaxRetries,
                MinRetryBackoff: opt.MinRetryBackoff,
                MaxRetryBackoff: opt.MaxRetryBackoff,

                DialTimeout:           opt.DialTimeout,
                ReadTimeout:           opt.ReadTimeout,
                WriteTimeout:          opt.WriteTimeout,
                ContextTimeoutEnabled: opt.ContextTimeoutEnabled,

                PoolFIFO:         opt.PoolFIFO,
                PoolSize:         opt.PoolSize,
                PoolTimeout:      opt.PoolTimeout,
                MinIdleConns:     opt.MinIdleConns,
                MaxIdleConns:     opt.MaxIdleConns,
                MaxActiveConns:   opt.MaxActiveConns,
                ConnMaxIdleTime:  opt.ConnMaxIdleTime,
                ConnMaxLifetime:  opt.ConnMaxLifetime,
                DisableIdentity:  opt.DisableIdentity,
                DisableIndentity: opt.DisableIdentity,
                IdentitySuffix:   opt.IdentitySuffix,
                TLSConfig:        opt.TLSConfig,
                // If ClusterSlots is populated, then we probably have an artificial
                // cluster whose nodes are not in clustering mode (otherwise there isn't
                // much use for ClusterSlots config).  This means we cannot execute the
                // READONLY command against that node -- setting readOnly to false in such
                // situations in the options below will prevent that from happening.
                readOnly:      opt.ReadOnly && opt.ClusterSlots == nil,
                UnstableResp3: opt.UnstableResp3,
        }
}

//------------------------------------------------------------------------------

type clusterNode struct {
        Client *Client

        latency    uint32 // atomic
        generation uint32 // atomic
        failing    uint32 // atomic
        loaded     uint32 // atomic

        // last time the latency measurement was performed for the node, stored in nanoseconds
        // from epoch
        lastLatencyMeasurement int64 // atomic
}

func newClusterNode(clOpt *ClusterOptions, addr string) *clusterNode {
        opt := clOpt.clientOptions()
        opt.Addr = addr
        node := clusterNode{
                Client: clOpt.NewClient(opt),
        }

        node.latency = math.MaxUint32
        if clOpt.RouteByLatency {
                go node.updateLatency()
        }

        return &node
}

func (n *clusterNode) String() string {
        return n.Client.String()
}

func (n *clusterNode) Close() error {
        return n.Client.Close()
}

const maximumNodeLatency = 1 * time.Minute

func (n *clusterNode) updateLatency() {
        const numProbe = 10
        var dur uint64

        successes := 0
        for i := 0; i < numProbe; i++ {
                time.Sleep(time.Duration(10+rand.Intn(10)) * time.Millisecond)

                start := time.Now()
                err := n.Client.Ping(context.TODO()).Err()
                if err == nil {
                        dur += uint64(time.Since(start) / time.Microsecond)
                        successes++
                }
        }

        var latency float64
        if successes == 0 {
                // If none of the pings worked, set latency to some arbitrarily high value so this node gets
                // least priority.
                latency = float64((maximumNodeLatency) / time.Microsecond)
        } else {
                latency = float64(dur) / float64(successes)
        }
        atomic.StoreUint32(&n.latency, uint32(latency+0.5))
        n.SetLastLatencyMeasurement(time.Now())
}

func (n *clusterNode) Latency() time.Duration {
        latency := atomic.LoadUint32(&n.latency)
        return time.Duration(latency) * time.Microsecond
}

func (n *clusterNode) MarkAsFailing() {
        atomic.StoreUint32(&n.failing, uint32(time.Now().Unix()))
        atomic.StoreUint32(&n.loaded, 0)
}

func (n *clusterNode) Failing() bool {
        const timeout = 15 // 15 seconds

        failing := atomic.LoadUint32(&n.failing)
        if failing == 0 {
                return false
        }
        if time.Now().Unix()-int64(failing) < timeout {
                return true
        }
        atomic.StoreUint32(&n.failing, 0)
        return false
}

func (n *clusterNode) Generation() uint32 {
        return atomic.LoadUint32(&n.generation)
}

func (n *clusterNode) LastLatencyMeasurement() int64 {
        return atomic.LoadInt64(&n.lastLatencyMeasurement)
}

func (n *clusterNode) SetGeneration(gen uint32) {
        for {
                v := atomic.LoadUint32(&n.generation)
                if gen < v || atomic.CompareAndSwapUint32(&n.generation, v, gen) {
                        break
                }
        }
}

func (n *clusterNode) SetLastLatencyMeasurement(t time.Time) {
        for {
                v := atomic.LoadInt64(&n.lastLatencyMeasurement)
                if t.UnixNano() < v || atomic.CompareAndSwapInt64(&n.lastLatencyMeasurement, v, t.UnixNano()) {
                        break
                }
        }
}

func (n *clusterNode) Loading() bool {
        loaded := atomic.LoadUint32(&n.loaded)
        if loaded == 1 {
                return false
        }

        // check if the node is loading
        ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
        defer cancel()

        err := n.Client.Ping(ctx).Err()
        loading := err != nil && isLoadingError(err)
        if !loading {
                atomic.StoreUint32(&n.loaded, 1)
        }
        return loading
}

//------------------------------------------------------------------------------

type clusterNodes struct {
        opt *ClusterOptions

        mu          sync.RWMutex
        addrs       []string
        nodes       map[string]*clusterNode
        activeAddrs []string
        closed      bool
        onNewNode   []func(rdb *Client)

        _generation uint32 // atomic
}

func newClusterNodes(opt *ClusterOptions) *clusterNodes {
        return &clusterNodes{
                opt: opt,

                addrs: opt.Addrs,
                nodes: make(map[string]*clusterNode),
        }
}

func (c *clusterNodes) Close() error {
        c.mu.Lock()
        defer c.mu.Unlock()

        if c.closed {
                return nil
        }
        c.closed = true

        var firstErr error
        for _, node := range c.nodes {
                if err := node.Client.Close(); err != nil && firstErr == nil {
                        firstErr = err
                }
        }

        c.nodes = nil
        c.activeAddrs = nil

        return firstErr
}

func (c *clusterNodes) OnNewNode(fn func(rdb *Client)) {
        c.mu.Lock()
        c.onNewNode = append(c.onNewNode, fn)
        c.mu.Unlock()
}

func (c *clusterNodes) Addrs() ([]string, error) {
        var addrs []string

        c.mu.RLock()
        closed := c.closed //nolint:ifshort
        if !closed {
                if len(c.activeAddrs) > 0 {
                        addrs = make([]string, len(c.activeAddrs))
                        copy(addrs, c.activeAddrs)
                } else {
                        addrs = make([]string, len(c.addrs))
                        copy(addrs, c.addrs)
                }
        }
        c.mu.RUnlock()

        if closed {
                return nil, pool.ErrClosed
        }
        if len(addrs) == 0 {
                return nil, errClusterNoNodes
        }
        return addrs, nil
}

func (c *clusterNodes) NextGeneration() uint32 {
        return atomic.AddUint32(&c._generation, 1)
}

// GC removes unused nodes.
func (c *clusterNodes) GC(generation uint32) {
        //nolint:prealloc
        var collected []*clusterNode

        c.mu.Lock()

        c.activeAddrs = c.activeAddrs[:0]
        now := time.Now()
        for addr, node := range c.nodes {
                if node.Generation() >= generation {
                        c.activeAddrs = append(c.activeAddrs, addr)
                        if c.opt.RouteByLatency && node.LastLatencyMeasurement() < now.Add(-minLatencyMeasurementInterval).UnixNano() {
                                go node.updateLatency()
                        }
                        continue
                }

                delete(c.nodes, addr)
                collected = append(collected, node)
        }

        c.mu.Unlock()

        for _, node := range collected {
                _ = node.Client.Close()
        }
}

func (c *clusterNodes) GetOrCreate(addr string) (*clusterNode, error) {
        node, err := c.get(addr)
        if err != nil {
                return nil, err
        }
        if node != nil {
                return node, nil
        }

        c.mu.Lock()
        defer c.mu.Unlock()

        if c.closed {
                return nil, pool.ErrClosed
        }

        node, ok := c.nodes[addr]
        if ok {
                return node, nil
        }

        node = newClusterNode(c.opt, addr)
        for _, fn := range c.onNewNode {
                fn(node.Client)
        }

        c.addrs = appendIfNotExists(c.addrs, addr)
        c.nodes[addr] = node

        return node, nil
}

func (c *clusterNodes) get(addr string) (*clusterNode, error) {
        var node *clusterNode
        var err error
        c.mu.RLock()
        if c.closed {
                err = pool.ErrClosed
        } else {
                node = c.nodes[addr]
        }
        c.mu.RUnlock()
        return node, err
}

func (c *clusterNodes) All() ([]*clusterNode, error) {
        c.mu.RLock()
        defer c.mu.RUnlock()

        if c.closed {
                return nil, pool.ErrClosed
        }

        cp := make([]*clusterNode, 0, len(c.nodes))
        for _, node := range c.nodes {
                cp = append(cp, node)
        }
        return cp, nil
}

func (c *clusterNodes) Random() (*clusterNode, error) {
        addrs, err := c.Addrs()
        if err != nil {
                return nil, err
        }

        n := rand.Intn(len(addrs))
        return c.GetOrCreate(addrs[n])
}

//------------------------------------------------------------------------------

type clusterSlot struct {
        start, end int
        nodes      []*clusterNode
}

type clusterSlotSlice []*clusterSlot

func (p clusterSlotSlice) Len() int {
        return len(p)
}

func (p clusterSlotSlice) Less(i, j int) bool {
        return p[i].start < p[j].start
}

func (p clusterSlotSlice) Swap(i, j int) {
        p[i], p[j] = p[j], p[i]
}

type clusterState struct {
        nodes   *clusterNodes
        Masters []*clusterNode
        Slaves  []*clusterNode

        slots []*clusterSlot

        generation uint32
        createdAt  time.Time
}

func newClusterState(
        nodes *clusterNodes, slots []ClusterSlot, origin string,
) (*clusterState, error) {
        c := clusterState{
                nodes: nodes,

                slots: make([]*clusterSlot, 0, len(slots)),

                generation: nodes.NextGeneration(),
                createdAt:  time.Now(),
        }

        originHost, _, _ := net.SplitHostPort(origin)
        isLoopbackOrigin := isLoopback(originHost)

        for _, slot := range slots {
                var nodes []*clusterNode
                for i, slotNode := range slot.Nodes {
                        addr := slotNode.Addr
                        if !isLoopbackOrigin {
                                addr = replaceLoopbackHost(addr, originHost)
                        }

                        node, err := c.nodes.GetOrCreate(addr)
                        if err != nil {
                                return nil, err
                        }

                        node.SetGeneration(c.generation)
                        nodes = append(nodes, node)

                        if i == 0 {
                                c.Masters = appendUniqueNode(c.Masters, node)
                        } else {
                                c.Slaves = appendUniqueNode(c.Slaves, node)
                        }
                }

                c.slots = append(c.slots, &clusterSlot{
                        start: slot.Start,
                        end:   slot.End,
                        nodes: nodes,
                })
        }

        sort.Sort(clusterSlotSlice(c.slots))

        time.AfterFunc(time.Minute, func() {
                nodes.GC(c.generation)
        })

        return &c, nil
}

func replaceLoopbackHost(nodeAddr, originHost string) string {
        nodeHost, nodePort, err := net.SplitHostPort(nodeAddr)
        if err != nil {
                return nodeAddr
        }

        nodeIP := net.ParseIP(nodeHost)
        if nodeIP == nil {
                return nodeAddr
        }

        if !nodeIP.IsLoopback() {
                return nodeAddr
        }

        // Use origin host which is not loopback and node port.
        return net.JoinHostPort(originHost, nodePort)
}

func isLoopback(host string) bool {
        ip := net.ParseIP(host)
        if ip == nil {
                return true
        }
        return ip.IsLoopback()
}

func (c *clusterState) slotMasterNode(slot int) (*clusterNode, error) {
        nodes := c.slotNodes(slot)
        if len(nodes) > 0 {
                return nodes[0], nil
        }
        return c.nodes.Random()
}

func (c *clusterState) slotSlaveNode(slot int) (*clusterNode, error) {
        nodes := c.slotNodes(slot)
        switch len(nodes) {
        case 0:
                return c.nodes.Random()
        case 1:
                return nodes[0], nil
        case 2:
                slave := nodes[1]
                if !slave.Failing() && !slave.Loading() {
                        return slave, nil
                }
                return nodes[0], nil
        default:
                var slave *clusterNode
                for i := 0; i < 10; i++ {
                        n := rand.Intn(len(nodes)-1) + 1
                        slave = nodes[n]
                        if !slave.Failing() && !slave.Loading() {
                                return slave, nil
                        }
                }

                // All slaves are loading - use master.
                return nodes[0], nil
        }
}

func (c *clusterState) slotClosestNode(slot int) (*clusterNode, error) {
        nodes := c.slotNodes(slot)
        if len(nodes) == 0 {
                return c.nodes.Random()
        }

        var allNodesFailing = true
        var (
                closestNonFailingNode *clusterNode
                closestNode           *clusterNode
                minLatency            time.Duration
        )

        // setting the max possible duration as zerovalue for minlatency
        minLatency = time.Duration(math.MaxInt64)

        for _, n := range nodes {
                if closestNode == nil || n.Latency() < minLatency {
                        closestNode = n
                        minLatency = n.Latency()
                        if !n.Failing() {
                                closestNonFailingNode = n
                                allNodesFailing = false
                        }
                }
        }

        // pick the healthly node with the lowest latency
        if !allNodesFailing && closestNonFailingNode != nil {
                return closestNonFailingNode, nil
        }

        // if all nodes are failing, we will pick the temporarily failing node with lowest latency
        if minLatency < maximumNodeLatency && closestNode != nil {
                internal.Logger.Printf(context.TODO(), "redis: all nodes are marked as failed, picking the temporarily failing node with lowest latency")
                return closestNode, nil
        }

        // If all nodes are having the maximum latency(all pings are failing) - return a random node across the cluster
        internal.Logger.Printf(context.TODO(), "redis: pings to all nodes are failing, picking a random node across the cluster")
        return c.nodes.Random()
}

func (c *clusterState) slotRandomNode(slot int) (*clusterNode, error) {
        nodes := c.slotNodes(slot)
        if len(nodes) == 0 {
                return c.nodes.Random()
        }
        if len(nodes) == 1 {
                return nodes[0], nil
        }
        randomNodes := rand.Perm(len(nodes))
        for _, idx := range randomNodes {
                if node := nodes[idx]; !node.Failing() {
                        return node, nil
                }
        }
        return nodes[randomNodes[0]], nil
}

func (c *clusterState) slotNodes(slot int) []*clusterNode {
        i := sort.Search(len(c.slots), func(i int) bool {
                return c.slots[i].end >= slot
        })
        if i >= len(c.slots) {
                return nil
        }
        x := c.slots[i]
        if slot >= x.start && slot <= x.end {
                return x.nodes
        }
        return nil
}

//------------------------------------------------------------------------------

type clusterStateHolder struct {
        load func(ctx context.Context) (*clusterState, error)

        state     atomic.Value
        reloading uint32 // atomic
}

func newClusterStateHolder(fn func(ctx context.Context) (*clusterState, error)) *clusterStateHolder {
        return &clusterStateHolder{
                load: fn,
        }
}

func (c *clusterStateHolder) Reload(ctx context.Context) (*clusterState, error) {
        state, err := c.load(ctx)
        if err != nil {
                return nil, err
        }
        c.state.Store(state)
        return state, nil
}

func (c *clusterStateHolder) LazyReload() {
        if !atomic.CompareAndSwapUint32(&c.reloading, 0, 1) {
                return
        }
        go func() {
                defer atomic.StoreUint32(&c.reloading, 0)

                _, err := c.Reload(context.Background())
                if err != nil {
                        return
                }
                time.Sleep(200 * time.Millisecond)
        }()
}

func (c *clusterStateHolder) Get(ctx context.Context) (*clusterState, error) {
        v := c.state.Load()
        if v == nil {
                return c.Reload(ctx)
        }

        state := v.(*clusterState)
        if time.Since(state.createdAt) > 10*time.Second {
                c.LazyReload()
        }
        return state, nil
}

func (c *clusterStateHolder) ReloadOrGet(ctx context.Context) (*clusterState, error) {
        state, err := c.Reload(ctx)
        if err == nil {
                return state, nil
        }
        return c.Get(ctx)
}

//------------------------------------------------------------------------------

// ClusterClient is a Redis Cluster client representing a pool of zero
// or more underlying connections. It's safe for concurrent use by
// multiple goroutines.
type ClusterClient struct {
        opt           *ClusterOptions
        nodes         *clusterNodes
        state         *clusterStateHolder
        cmdsInfoCache *cmdsInfoCache
        cmdable
        hooksMixin
}

// NewClusterClient returns a Redis Cluster client as described in
// http://redis.io/topics/cluster-spec.
func NewClusterClient(opt *ClusterOptions) *ClusterClient {
        if opt == nil {
                panic("redis: NewClusterClient nil options")
        }
        opt.init()

        c := &ClusterClient{
                opt:   opt,
                nodes: newClusterNodes(opt),
        }

        c.state = newClusterStateHolder(c.loadState)
        c.cmdsInfoCache = newCmdsInfoCache(c.cmdsInfo)
        c.cmdable = c.Process

        c.initHooks(hooks{
                dial:       nil,
                process:    c.process,
                pipeline:   c.processPipeline,
                txPipeline: c.processTxPipeline,
        })

        return c
}

// Options returns read-only Options that were used to create the client.
func (c *ClusterClient) Options() *ClusterOptions {
        return c.opt
}

// ReloadState reloads cluster state. If available it calls ClusterSlots func
// to get cluster slots information.
func (c *ClusterClient) ReloadState(ctx context.Context) {
        c.state.LazyReload()
}

// Close closes the cluster client, releasing any open resources.
//
// It is rare to Close a ClusterClient, as the ClusterClient is meant
// to be long-lived and shared between many goroutines.
func (c *ClusterClient) Close() error {
        return c.nodes.Close()
}

func (c *ClusterClient) Process(ctx context.Context, cmd Cmder) error {
        err := c.processHook(ctx, cmd)
        cmd.SetErr(err)
        return err
}

func (c *ClusterClient) process(ctx context.Context, cmd Cmder) error {
        slot := c.cmdSlot(cmd, -1)
        var node *clusterNode
        var moved bool
        var ask bool
        var lastErr error
        for attempt := 0; attempt <= c.opt.MaxRedirects; attempt++ {
                // MOVED and ASK responses are not transient errors that require retry delay; they
                // should be attempted immediately.
                if attempt > 0 && !moved && !ask {
                        if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
                                return err
                        }
                }

                if node == nil {
                        var err error
                        node, err = c.cmdNode(ctx, cmd.Name(), slot)
                        if err != nil {
                                return err
                        }
                }

                if ask {
                        ask = false

                        pipe := node.Client.Pipeline()
                        _ = pipe.Process(ctx, NewCmd(ctx, "asking"))
                        _ = pipe.Process(ctx, cmd)
                        _, lastErr = pipe.Exec(ctx)
                } else {
                        lastErr = node.Client.Process(ctx, cmd)
                }

                // If there is no error - we are done.
                if lastErr == nil {
                        return nil
                }
                if isReadOnly := isReadOnlyError(lastErr); isReadOnly || lastErr == pool.ErrClosed {
                        if isReadOnly {
                                c.state.LazyReload()
                        }
                        node = nil
                        continue
                }

                // If slave is loading - pick another node.
                if c.opt.ReadOnly && isLoadingError(lastErr) {
                        node.MarkAsFailing()
                        node = nil
                        continue
                }

                var addr string
                moved, ask, addr = isMovedError(lastErr)
                if moved || ask {
                        c.state.LazyReload()

                        var err error
                        node, err = c.nodes.GetOrCreate(addr)
                        if err != nil {
                                return err
                        }
                        continue
                }

                if shouldRetry(lastErr, cmd.readTimeout() == nil) {
                        // First retry the same node.
                        if attempt == 0 {
                                continue
                        }

                        // Second try another node.
                        node.MarkAsFailing()
                        node = nil
                        continue
                }

                return lastErr
        }
        return lastErr
}

func (c *ClusterClient) OnNewNode(fn func(rdb *Client)) {
        c.nodes.OnNewNode(fn)
}

// ForEachMaster concurrently calls the fn on each master node in the cluster.
// It returns the first error if any.
func (c *ClusterClient) ForEachMaster(
        ctx context.Context,
        fn func(ctx context.Context, client *Client) error,
) error {
        state, err := c.state.ReloadOrGet(ctx)
        if err != nil {
                return err
        }

        var wg sync.WaitGroup
        errCh := make(chan error, 1)

        for _, master := range state.Masters {
                wg.Add(1)
                go func(node *clusterNode) {
                        defer wg.Done()
                        err := fn(ctx, node.Client)
                        if err != nil {
                                select {
                                case errCh <- err:
                                default:
                                }
                        }
                }(master)
        }

        wg.Wait()

        select {
        case err := <-errCh:
                return err
        default:
                return nil
        }
}

// ForEachSlave concurrently calls the fn on each slave node in the cluster.
// It returns the first error if any.
func (c *ClusterClient) ForEachSlave(
        ctx context.Context,
        fn func(ctx context.Context, client *Client) error,
) error {
        state, err := c.state.ReloadOrGet(ctx)
        if err != nil {
                return err
        }

        var wg sync.WaitGroup
        errCh := make(chan error, 1)

        for _, slave := range state.Slaves {
                wg.Add(1)
                go func(node *clusterNode) {
                        defer wg.Done()
                        err := fn(ctx, node.Client)
                        if err != nil {
                                select {
                                case errCh <- err:
                                default:
                                }
                        }
                }(slave)
        }

        wg.Wait()

        select {
        case err := <-errCh:
                return err
        default:
                return nil
        }
}

// ForEachShard concurrently calls the fn on each known node in the cluster.
// It returns the first error if any.
func (c *ClusterClient) ForEachShard(
        ctx context.Context,
        fn func(ctx context.Context, client *Client) error,
) error {
        state, err := c.state.ReloadOrGet(ctx)
        if err != nil {
                return err
        }

        var wg sync.WaitGroup
        errCh := make(chan error, 1)

        worker := func(node *clusterNode) {
                defer wg.Done()
                err := fn(ctx, node.Client)
                if err != nil {
                        select {
                        case errCh <- err:
                        default:
                        }
                }
        }

        for _, node := range state.Masters {
                wg.Add(1)
                go worker(node)
        }
        for _, node := range state.Slaves {
                wg.Add(1)
                go worker(node)
        }

        wg.Wait()

        select {
        case err := <-errCh:
                return err
        default:
                return nil
        }
}

// PoolStats returns accumulated connection pool stats.
func (c *ClusterClient) PoolStats() *PoolStats {
        var acc PoolStats

        state, _ := c.state.Get(context.TODO())
        if state == nil {
                return &acc
        }

        for _, node := range state.Masters {
                s := node.Client.connPool.Stats()
                acc.Hits += s.Hits
                acc.Misses += s.Misses
                acc.Timeouts += s.Timeouts

                acc.TotalConns += s.TotalConns
                acc.IdleConns += s.IdleConns
                acc.StaleConns += s.StaleConns
        }

        for _, node := range state.Slaves {
                s := node.Client.connPool.Stats()
                acc.Hits += s.Hits
                acc.Misses += s.Misses
                acc.Timeouts += s.Timeouts

                acc.TotalConns += s.TotalConns
                acc.IdleConns += s.IdleConns
                acc.StaleConns += s.StaleConns
        }

        return &acc
}

func (c *ClusterClient) loadState(ctx context.Context) (*clusterState, error) {
        if c.opt.ClusterSlots != nil {
                slots, err := c.opt.ClusterSlots(ctx)
                if err != nil {
                        return nil, err
                }
                return newClusterState(c.nodes, slots, "")
        }

        addrs, err := c.nodes.Addrs()
        if err != nil {
                return nil, err
        }

        var firstErr error

        for _, idx := range rand.Perm(len(addrs)) {
                addr := addrs[idx]

                node, err := c.nodes.GetOrCreate(addr)
                if err != nil {
                        if firstErr == nil {
                                firstErr = err
                        }
                        continue
                }

                slots, err := node.Client.ClusterSlots(ctx).Result()
                if err != nil {
                        if firstErr == nil {
                                firstErr = err
                        }
                        continue
                }

                return newClusterState(c.nodes, slots, node.Client.opt.Addr)
        }

        /*
         * No node is connectable. It's possible that all nodes' IP has changed.
         * Clear activeAddrs to let client be able to re-connect using the initial
         * setting of the addresses (e.g. [redis-cluster-0:6379, redis-cluster-1:6379]),
         * which might have chance to resolve domain name and get updated IP address.
         */
        c.nodes.mu.Lock()
        c.nodes.activeAddrs = nil
        c.nodes.mu.Unlock()

        return nil, firstErr
}

func (c *ClusterClient) Pipeline() Pipeliner {
        pipe := Pipeline{
                exec: pipelineExecer(c.processPipelineHook),
        }
        pipe.init()
        return &pipe
}

func (c *ClusterClient) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.Pipeline().Pipelined(ctx, fn)
}

func (c *ClusterClient) processPipeline(ctx context.Context, cmds []Cmder) error {
        cmdsMap := newCmdsMap()

        if err := c.mapCmdsByNode(ctx, cmdsMap, cmds); err != nil {
                setCmdsErr(cmds, err)
                return err
        }

        for attempt := 0; attempt <= c.opt.MaxRedirects; attempt++ {
                if attempt > 0 {
                        if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
                                setCmdsErr(cmds, err)
                                return err
                        }
                }

                failedCmds := newCmdsMap()
                var wg sync.WaitGroup

                for node, cmds := range cmdsMap.m {
                        wg.Add(1)
                        go func(node *clusterNode, cmds []Cmder) {
                                defer wg.Done()
                                c.processPipelineNode(ctx, node, cmds, failedCmds)
                        }(node, cmds)
                }

                wg.Wait()
                if len(failedCmds.m) == 0 {
                        break
                }
                cmdsMap = failedCmds
        }

        return cmdsFirstErr(cmds)
}

func (c *ClusterClient) mapCmdsByNode(ctx context.Context, cmdsMap *cmdsMap, cmds []Cmder) error {
        state, err := c.state.Get(ctx)
        if err != nil {
                return err
        }

        preferredRandomSlot := -1
        if c.opt.ReadOnly && c.cmdsAreReadOnly(ctx, cmds) {
                for _, cmd := range cmds {
                        slot := c.cmdSlot(cmd, preferredRandomSlot)
                        if preferredRandomSlot == -1 {
                                preferredRandomSlot = slot
                        }
                        node, err := c.slotReadOnlyNode(state, slot)
                        if err != nil {
                                return err
                        }
                        cmdsMap.Add(node, cmd)
                }
                return nil
        }

        for _, cmd := range cmds {
                slot := c.cmdSlot(cmd, preferredRandomSlot)
                if preferredRandomSlot == -1 {
                        preferredRandomSlot = slot
                }
                node, err := state.slotMasterNode(slot)
                if err != nil {
                        return err
                }
                cmdsMap.Add(node, cmd)
        }
        return nil
}

func (c *ClusterClient) cmdsAreReadOnly(ctx context.Context, cmds []Cmder) bool {
        for _, cmd := range cmds {
                cmdInfo := c.cmdInfo(ctx, cmd.Name())
                if cmdInfo == nil || !cmdInfo.ReadOnly {
                        return false
                }
        }
        return true
}

func (c *ClusterClient) processPipelineNode(
        ctx context.Context, node *clusterNode, cmds []Cmder, failedCmds *cmdsMap,
) {
        _ = node.Client.withProcessPipelineHook(ctx, cmds, func(ctx context.Context, cmds []Cmder) error {
                cn, err := node.Client.getConn(ctx)
                if err != nil {
                        if !isContextError(err) {
                                node.MarkAsFailing()
                        }
                        _ = c.mapCmdsByNode(ctx, failedCmds, cmds)
                        setCmdsErr(cmds, err)
                        return err
                }

                var processErr error
                defer func() {
                        node.Client.releaseConn(ctx, cn, processErr)
                }()
                processErr = c.processPipelineNodeConn(ctx, node, cn, cmds, failedCmds)

                return processErr
        })
}

func (c *ClusterClient) processPipelineNodeConn(
        ctx context.Context, node *clusterNode, cn *pool.Conn, cmds []Cmder, failedCmds *cmdsMap,
) error {
        if err := cn.WithWriter(c.context(ctx), c.opt.WriteTimeout, func(wr *proto.Writer) error {
                return writeCmds(wr, cmds)
        }); err != nil {
                if isBadConn(err, false, node.Client.getAddr()) {
                        node.MarkAsFailing()
                }
                if shouldRetry(err, true) {
                        _ = c.mapCmdsByNode(ctx, failedCmds, cmds)
                }
                setCmdsErr(cmds, err)
                return err
        }

        return cn.WithReader(c.context(ctx), c.opt.ReadTimeout, func(rd *proto.Reader) error {
                return c.pipelineReadCmds(ctx, node, rd, cmds, failedCmds)
        })
}

func (c *ClusterClient) pipelineReadCmds(
        ctx context.Context,
        node *clusterNode,
        rd *proto.Reader,
        cmds []Cmder,
        failedCmds *cmdsMap,
) error {
        for i, cmd := range cmds {
                err := cmd.readReply(rd)
                cmd.SetErr(err)

                if err == nil {
                        continue
                }

                if c.checkMovedErr(ctx, cmd, err, failedCmds) {
                        continue
                }

                if c.opt.ReadOnly && isBadConn(err, false, node.Client.getAddr()) {
                        node.MarkAsFailing()
                }

                if !isRedisError(err) {
                        if shouldRetry(err, true) {
                                _ = c.mapCmdsByNode(ctx, failedCmds, cmds)
                        }
                        setCmdsErr(cmds[i+1:], err)
                        return err
                }
        }

        if err := cmds[0].Err(); err != nil && shouldRetry(err, true) {
                _ = c.mapCmdsByNode(ctx, failedCmds, cmds)
                return err
        }

        return nil
}

func (c *ClusterClient) checkMovedErr(
        ctx context.Context, cmd Cmder, err error, failedCmds *cmdsMap,
) bool {
        moved, ask, addr := isMovedError(err)
        if !moved && !ask {
                return false
        }

        node, err := c.nodes.GetOrCreate(addr)
        if err != nil {
                return false
        }

        if moved {
                c.state.LazyReload()
                failedCmds.Add(node, cmd)
                return true
        }

        if ask {
                failedCmds.Add(node, NewCmd(ctx, "asking"), cmd)
                return true
        }

        panic("not reached")
}

// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
func (c *ClusterClient) TxPipeline() Pipeliner {
        pipe := Pipeline{
                exec: func(ctx context.Context, cmds []Cmder) error {
                        cmds = wrapMultiExec(ctx, cmds)
                        return c.processTxPipelineHook(ctx, cmds)
                },
        }
        pipe.init()
        return &pipe
}

func (c *ClusterClient) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.TxPipeline().Pipelined(ctx, fn)
}

func (c *ClusterClient) processTxPipeline(ctx context.Context, cmds []Cmder) error {
        // Trim multi .. exec.
        cmds = cmds[1 : len(cmds)-1]

        if len(cmds) == 0 {
                return nil
        }

        state, err := c.state.Get(ctx)
        if err != nil {
                setCmdsErr(cmds, err)
                return err
        }

        keyedCmdsBySlot := c.slottedKeyedCommands(cmds)
        slot := -1
        switch len(keyedCmdsBySlot) {
        case 0:
                slot = hashtag.RandomSlot()
        case 1:
                for sl := range keyedCmdsBySlot {
                        slot = sl
                        break
                }
        default:
                // TxPipeline does not support cross slot transaction.
                setCmdsErr(cmds, ErrCrossSlot)
                return ErrCrossSlot
        }

        node, err := state.slotMasterNode(slot)
        if err != nil {
                setCmdsErr(cmds, err)
                return err
        }

        cmdsMap := map[*clusterNode][]Cmder{node: cmds}
        for attempt := 0; attempt <= c.opt.MaxRedirects; attempt++ {
                if attempt > 0 {
                        if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
                                setCmdsErr(cmds, err)
                                return err
                        }
                }

                failedCmds := newCmdsMap()
                var wg sync.WaitGroup

                for node, cmds := range cmdsMap {
                        wg.Add(1)
                        go func(node *clusterNode, cmds []Cmder) {
                                defer wg.Done()
                                c.processTxPipelineNode(ctx, node, cmds, failedCmds)
                        }(node, cmds)
                }

                wg.Wait()
                if len(failedCmds.m) == 0 {
                        break
                }
                cmdsMap = failedCmds.m
        }

        return cmdsFirstErr(cmds)
}

// slottedKeyedCommands returns a map of slot to commands taking into account
// only commands that have keys.
func (c *ClusterClient) slottedKeyedCommands(cmds []Cmder) map[int][]Cmder {
        cmdsSlots := map[int][]Cmder{}

        preferredRandomSlot := -1
        for _, cmd := range cmds {
                if cmdFirstKeyPos(cmd) == 0 {
                        continue
                }

                slot := c.cmdSlot(cmd, preferredRandomSlot)
                if preferredRandomSlot == -1 {
                        preferredRandomSlot = slot
                }

                cmdsSlots[slot] = append(cmdsSlots[slot], cmd)
        }

        return cmdsSlots
}

func (c *ClusterClient) processTxPipelineNode(
        ctx context.Context, node *clusterNode, cmds []Cmder, failedCmds *cmdsMap,
) {
        cmds = wrapMultiExec(ctx, cmds)
        _ = node.Client.withProcessPipelineHook(ctx, cmds, func(ctx context.Context, cmds []Cmder) error {
                cn, err := node.Client.getConn(ctx)
                if err != nil {
                        _ = c.mapCmdsByNode(ctx, failedCmds, cmds)
                        setCmdsErr(cmds, err)
                        return err
                }

                var processErr error
                defer func() {
                        node.Client.releaseConn(ctx, cn, processErr)
                }()
                processErr = c.processTxPipelineNodeConn(ctx, node, cn, cmds, failedCmds)

                return processErr
        })
}

func (c *ClusterClient) processTxPipelineNodeConn(
        ctx context.Context, _ *clusterNode, cn *pool.Conn, cmds []Cmder, failedCmds *cmdsMap,
) error {
        if err := cn.WithWriter(c.context(ctx), c.opt.WriteTimeout, func(wr *proto.Writer) error {
                return writeCmds(wr, cmds)
        }); err != nil {
                if shouldRetry(err, true) {
                        _ = c.mapCmdsByNode(ctx, failedCmds, cmds)
                }
                setCmdsErr(cmds, err)
                return err
        }

        return cn.WithReader(c.context(ctx), c.opt.ReadTimeout, func(rd *proto.Reader) error {
                statusCmd := cmds[0].(*StatusCmd)
                // Trim multi and exec.
                trimmedCmds := cmds[1 : len(cmds)-1]

                if err := c.txPipelineReadQueued(
                        ctx, rd, statusCmd, trimmedCmds, failedCmds,
                ); err != nil {
                        setCmdsErr(cmds, err)

                        moved, ask, addr := isMovedError(err)
                        if moved || ask {
                                return c.cmdsMoved(ctx, trimmedCmds, moved, ask, addr, failedCmds)
                        }

                        return err
                }

                return pipelineReadCmds(rd, trimmedCmds)
        })
}

func (c *ClusterClient) txPipelineReadQueued(
        ctx context.Context,
        rd *proto.Reader,
        statusCmd *StatusCmd,
        cmds []Cmder,
        failedCmds *cmdsMap,
) error {
        // Parse queued replies.
        if err := statusCmd.readReply(rd); err != nil {
                return err
        }

        for _, cmd := range cmds {
                err := statusCmd.readReply(rd)
                if err == nil || c.checkMovedErr(ctx, cmd, err, failedCmds) || isRedisError(err) {
                        continue
                }
                return err
        }

        // Parse number of replies.
        line, err := rd.ReadLine()
        if err != nil {
                if err == Nil {
                        err = TxFailedErr
                }
                return err
        }

        if line[0] != proto.RespArray {
                return fmt.Errorf("redis: expected '*', but got line %q", line)
        }

        return nil
}

func (c *ClusterClient) cmdsMoved(
        ctx context.Context, cmds []Cmder,
        moved, ask bool,
        addr string,
        failedCmds *cmdsMap,
) error {
        node, err := c.nodes.GetOrCreate(addr)
        if err != nil {
                return err
        }

        if moved {
                c.state.LazyReload()
                for _, cmd := range cmds {
                        failedCmds.Add(node, cmd)
                }
                return nil
        }

        if ask {
                for _, cmd := range cmds {
                        failedCmds.Add(node, NewCmd(ctx, "asking"), cmd)
                }
                return nil
        }

        return nil
}

func (c *ClusterClient) Watch(ctx context.Context, fn func(*Tx) error, keys ...string) error {
        if len(keys) == 0 {
                return fmt.Errorf("redis: Watch requires at least one key")
        }

        slot := hashtag.Slot(keys[0])
        for _, key := range keys[1:] {
                if hashtag.Slot(key) != slot {
                        err := fmt.Errorf("redis: Watch requires all keys to be in the same slot")
                        return err
                }
        }

        node, err := c.slotMasterNode(ctx, slot)
        if err != nil {
                return err
        }

        for attempt := 0; attempt <= c.opt.MaxRedirects; attempt++ {
                if attempt > 0 {
                        if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
                                return err
                        }
                }

                err = node.Client.Watch(ctx, fn, keys...)
                if err == nil {
                        break
                }

                moved, ask, addr := isMovedError(err)
                if moved || ask {
                        node, err = c.nodes.GetOrCreate(addr)
                        if err != nil {
                                return err
                        }
                        continue
                }

                if isReadOnly := isReadOnlyError(err); isReadOnly || err == pool.ErrClosed {
                        if isReadOnly {
                                c.state.LazyReload()
                        }
                        node, err = c.slotMasterNode(ctx, slot)
                        if err != nil {
                                return err
                        }
                        continue
                }

                if shouldRetry(err, true) {
                        continue
                }

                return err
        }

        return err
}

func (c *ClusterClient) pubSub() *PubSub {
        var node *clusterNode
        pubsub := &PubSub{
                opt: c.opt.clientOptions(),

                newConn: func(ctx context.Context, channels []string) (*pool.Conn, error) {
                        if node != nil {
                                panic("node != nil")
                        }

                        var err error
                        if len(channels) > 0 {
                                slot := hashtag.Slot(channels[0])
                                node, err = c.slotMasterNode(ctx, slot)
                        } else {
                                node, err = c.nodes.Random()
                        }
                        if err != nil {
                                return nil, err
                        }

                        cn, err := node.Client.newConn(context.TODO())
                        if err != nil {
                                node = nil

                                return nil, err
                        }

                        return cn, nil
                },
                closeConn: func(cn *pool.Conn) error {
                        err := node.Client.connPool.CloseConn(cn)
                        node = nil
                        return err
                },
        }
        pubsub.init()

        return pubsub
}

// Subscribe subscribes the client to the specified channels.
// Channels can be omitted to create empty subscription.
func (c *ClusterClient) Subscribe(ctx context.Context, channels ...string) *PubSub {
        pubsub := c.pubSub()
        if len(channels) > 0 {
                _ = pubsub.Subscribe(ctx, channels...)
        }
        return pubsub
}

// PSubscribe subscribes the client to the given patterns.
// Patterns can be omitted to create empty subscription.
func (c *ClusterClient) PSubscribe(ctx context.Context, channels ...string) *PubSub {
        pubsub := c.pubSub()
        if len(channels) > 0 {
                _ = pubsub.PSubscribe(ctx, channels...)
        }
        return pubsub
}

// SSubscribe Subscribes the client to the specified shard channels.
func (c *ClusterClient) SSubscribe(ctx context.Context, channels ...string) *PubSub {
        pubsub := c.pubSub()
        if len(channels) > 0 {
                _ = pubsub.SSubscribe(ctx, channels...)
        }
        return pubsub
}

func (c *ClusterClient) retryBackoff(attempt int) time.Duration {
        return internal.RetryBackoff(attempt, c.opt.MinRetryBackoff, c.opt.MaxRetryBackoff)
}

func (c *ClusterClient) cmdsInfo(ctx context.Context) (map[string]*CommandInfo, error) {
        // Try 3 random nodes.
        const nodeLimit = 3

        addrs, err := c.nodes.Addrs()
        if err != nil {
                return nil, err
        }

        var firstErr error

        perm := rand.Perm(len(addrs))
        if len(perm) > nodeLimit {
                perm = perm[:nodeLimit]
        }

        for _, idx := range perm {
                addr := addrs[idx]

                node, err := c.nodes.GetOrCreate(addr)
                if err != nil {
                        if firstErr == nil {
                                firstErr = err
                        }
                        continue
                }

                info, err := node.Client.Command(ctx).Result()
                if err == nil {
                        return info, nil
                }
                if firstErr == nil {
                        firstErr = err
                }
        }

        if firstErr == nil {
                panic("not reached")
        }
        return nil, firstErr
}

func (c *ClusterClient) cmdInfo(ctx context.Context, name string) *CommandInfo {
        cmdsInfo, err := c.cmdsInfoCache.Get(ctx)
        if err != nil {
                internal.Logger.Printf(context.TODO(), "getting command info: %s", err)
                return nil
        }

        info := cmdsInfo[name]
        if info == nil {
                internal.Logger.Printf(context.TODO(), "info for cmd=%s not found", name)
        }
        return info
}

func (c *ClusterClient) cmdSlot(cmd Cmder, preferredRandomSlot int) int {
        args := cmd.Args()
        if args[0] == "cluster" && (args[1] == "getkeysinslot" || args[1] == "countkeysinslot") {
                return args[2].(int)
        }

        return cmdSlot(cmd, cmdFirstKeyPos(cmd), preferredRandomSlot)
}

func cmdSlot(cmd Cmder, pos int, preferredRandomSlot int) int {
        if pos == 0 {
                if preferredRandomSlot != -1 {
                        return preferredRandomSlot
                }
                return hashtag.RandomSlot()
        }
        firstKey := cmd.stringArg(pos)
        return hashtag.Slot(firstKey)
}

func (c *ClusterClient) cmdNode(
        ctx context.Context,
        cmdName string,
        slot int,
) (*clusterNode, error) {
        state, err := c.state.Get(ctx)
        if err != nil {
                return nil, err
        }

        if c.opt.ReadOnly {
                cmdInfo := c.cmdInfo(ctx, cmdName)
                if cmdInfo != nil && cmdInfo.ReadOnly {
                        return c.slotReadOnlyNode(state, slot)
                }
        }
        return state.slotMasterNode(slot)
}

func (c *ClusterClient) slotReadOnlyNode(state *clusterState, slot int) (*clusterNode, error) {
        if c.opt.RouteByLatency {
                return state.slotClosestNode(slot)
        }
        if c.opt.RouteRandomly {
                return state.slotRandomNode(slot)
        }
        return state.slotSlaveNode(slot)
}

func (c *ClusterClient) slotMasterNode(ctx context.Context, slot int) (*clusterNode, error) {
        state, err := c.state.Get(ctx)
        if err != nil {
                return nil, err
        }
        return state.slotMasterNode(slot)
}

// SlaveForKey gets a client for a replica node to run any command on it.
// This is especially useful if we want to run a particular lua script which has
// only read only commands on the replica.
// This is because other redis commands generally have a flag that points that
// they are read only and automatically run on the replica nodes
// if ClusterOptions.ReadOnly flag is set to true.
func (c *ClusterClient) SlaveForKey(ctx context.Context, key string) (*Client, error) {
        state, err := c.state.Get(ctx)
        if err != nil {
                return nil, err
        }
        slot := hashtag.Slot(key)
        node, err := c.slotReadOnlyNode(state, slot)
        if err != nil {
                return nil, err
        }
        return node.Client, err
}

// MasterForKey return a client to the master node for a particular key.
func (c *ClusterClient) MasterForKey(ctx context.Context, key string) (*Client, error) {
        slot := hashtag.Slot(key)
        node, err := c.slotMasterNode(ctx, slot)
        if err != nil {
                return nil, err
        }
        return node.Client, err
}

func (c *ClusterClient) context(ctx context.Context) context.Context {
        if c.opt.ContextTimeoutEnabled {
                return ctx
        }
        return context.Background()
}

func appendUniqueNode(nodes []*clusterNode, node *clusterNode) []*clusterNode {
        for _, n := range nodes {
                if n == node {
                        return nodes
                }
        }
        return append(nodes, node)
}

func appendIfNotExists(ss []string, es ...string) []string {
loop:
        for _, e := range es {
                for _, s := range ss {
                        if s == e {
                                continue loop
                        }
                }
                ss = append(ss, e)
        }
        return ss
}

//------------------------------------------------------------------------------

type cmdsMap struct {
        mu sync.Mutex
        m  map[*clusterNode][]Cmder
}

func newCmdsMap() *cmdsMap {
        return &cmdsMap{
                m: make(map[*clusterNode][]Cmder),
        }
}

func (m *cmdsMap) Add(node *clusterNode, cmds ...Cmder) {
        m.mu.Lock()
        m.m[node] = append(m.m[node], cmds...)
        m.mu.Unlock()
}

package redis

import (
        "context"
        "sync"
        "sync/atomic"
)

func (c *ClusterClient) DBSize(ctx context.Context) *IntCmd {
        cmd := NewIntCmd(ctx, "dbsize")
        _ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
                var size int64
                err := c.ForEachMaster(ctx, func(ctx context.Context, master *Client) error {
                        n, err := master.DBSize(ctx).Result()
                        if err != nil {
                                return err
                        }
                        atomic.AddInt64(&size, n)
                        return nil
                })
                if err != nil {
                        cmd.SetErr(err)
                } else {
                        cmd.val = size
                }
                return nil
        })
        return cmd
}

func (c *ClusterClient) ScriptLoad(ctx context.Context, script string) *StringCmd {
        cmd := NewStringCmd(ctx, "script", "load", script)
        _ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
                var mu sync.Mutex
                err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
                        val, err := shard.ScriptLoad(ctx, script).Result()
                        if err != nil {
                                return err
                        }

                        mu.Lock()
                        if cmd.Val() == "" {
                                cmd.val = val
                        }
                        mu.Unlock()

                        return nil
                })
                if err != nil {
                        cmd.SetErr(err)
                }
                return nil
        })
        return cmd
}

func (c *ClusterClient) ScriptFlush(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "script", "flush")
        _ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
                err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
                        return shard.ScriptFlush(ctx).Err()
                })
                if err != nil {
                        cmd.SetErr(err)
                }
                return nil
        })
        return cmd
}

func (c *ClusterClient) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
        args := make([]interface{}, 2+len(hashes))
        args[0] = "script"
        args[1] = "exists"
        for i, hash := range hashes {
                args[2+i] = hash
        }
        cmd := NewBoolSliceCmd(ctx, args...)

        result := make([]bool, len(hashes))
        for i := range result {
                result[i] = true
        }

        _ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
                var mu sync.Mutex
                err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
                        val, err := shard.ScriptExists(ctx, hashes...).Result()
                        if err != nil {
                                return err
                        }

                        mu.Lock()
                        for i, v := range val {
                                result[i] = result[i] && v
                        }
                        mu.Unlock()

                        return nil
                })
                if err != nil {
                        cmd.SetErr(err)
                } else {
                        cmd.val = result
                }
                return nil
        })
        return cmd
}

package redis

import (
        "context"
        "errors"
)

type pipelineExecer func(context.Context, []Cmder) error

// Pipeliner is an mechanism to realise Redis Pipeline technique.
//
// Pipelining is a technique to extremely speed up processing by packing
// operations to batches, send them at once to Redis and read a replies in a
// single step.
// See https://redis.io/topics/pipelining
//
// Pay attention, that Pipeline is not a transaction, so you can get unexpected
// results in case of big pipelines and small read/write timeouts.
// Redis client has retransmission logic in case of timeouts, pipeline
// can be retransmitted and commands can be executed more then once.
// To avoid this: it is good idea to use reasonable bigger read/write timeouts
// depends of your batch size and/or use TxPipeline.
type Pipeliner interface {
        StatefulCmdable

        // Len is to obtain the number of commands in the pipeline that have not yet been executed.
        Len() int

        // Do is an API for executing any command.
        // If a certain Redis command is not yet supported, you can use Do to execute it.
        Do(ctx context.Context, args ...interface{}) *Cmd

        // Process is to put the commands to be executed into the pipeline buffer.
        Process(ctx context.Context, cmd Cmder) error

        // Discard is to discard all commands in the cache that have not yet been executed.
        Discard()

        // Exec is to send all the commands buffered in the pipeline to the redis-server.
        Exec(ctx context.Context) ([]Cmder, error)
}

var _ Pipeliner = (*Pipeline)(nil)

// Pipeline implements pipelining as described in
// http://redis.io/topics/pipelining.
// Please note: it is not safe for concurrent use by multiple goroutines.
type Pipeline struct {
        cmdable
        statefulCmdable

        exec pipelineExecer
        cmds []Cmder
}

func (c *Pipeline) init() {
        c.cmdable = c.Process
        c.statefulCmdable = c.Process
}

// Len returns the number of queued commands.
func (c *Pipeline) Len() int {
        return len(c.cmds)
}

// Do queues the custom command for later execution.
func (c *Pipeline) Do(ctx context.Context, args ...interface{}) *Cmd {
        cmd := NewCmd(ctx, args...)
        if len(args) == 0 {
                cmd.SetErr(errors.New("redis: please enter the command to be executed"))
                return cmd
        }
        _ = c.Process(ctx, cmd)
        return cmd
}

// Process queues the cmd for later execution.
func (c *Pipeline) Process(ctx context.Context, cmd Cmder) error {
        c.cmds = append(c.cmds, cmd)
        return nil
}

// Discard resets the pipeline and discards queued commands.
func (c *Pipeline) Discard() {
        c.cmds = c.cmds[:0]
}

// Exec executes all previously queued commands using one
// client-server roundtrip.
//
// Exec always returns list of commands and error of the first failed
// command if any.
func (c *Pipeline) Exec(ctx context.Context) ([]Cmder, error) {
        if len(c.cmds) == 0 {
                return nil, nil
        }

        cmds := c.cmds
        c.cmds = nil

        return cmds, c.exec(ctx, cmds)
}

func (c *Pipeline) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        if err := fn(c); err != nil {
                return nil, err
        }
        return c.Exec(ctx)
}

func (c *Pipeline) Pipeline() Pipeliner {
        return c
}

func (c *Pipeline) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.Pipelined(ctx, fn)
}

func (c *Pipeline) TxPipeline() Pipeliner {
        return c
}

package redis

import (
        "context"
        "fmt"

        "github.com/redis/go-redis/v9/internal/proto"
)

type ProbabilisticCmdable interface {
        BFAdd(ctx context.Context, key string, element interface{}) *BoolCmd
        BFCard(ctx context.Context, key string) *IntCmd
        BFExists(ctx context.Context, key string, element interface{}) *BoolCmd
        BFInfo(ctx context.Context, key string) *BFInfoCmd
        BFInfoArg(ctx context.Context, key, option string) *BFInfoCmd
        BFInfoCapacity(ctx context.Context, key string) *BFInfoCmd
        BFInfoSize(ctx context.Context, key string) *BFInfoCmd
        BFInfoFilters(ctx context.Context, key string) *BFInfoCmd
        BFInfoItems(ctx context.Context, key string) *BFInfoCmd
        BFInfoExpansion(ctx context.Context, key string) *BFInfoCmd
        BFInsert(ctx context.Context, key string, options *BFInsertOptions, elements ...interface{}) *BoolSliceCmd
        BFMAdd(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd
        BFMExists(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd
        BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *StatusCmd
        BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *StatusCmd
        BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *StatusCmd
        BFReserveWithArgs(ctx context.Context, key string, options *BFReserveOptions) *StatusCmd
        BFScanDump(ctx context.Context, key string, iterator int64) *ScanDumpCmd
        BFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *StatusCmd

        CFAdd(ctx context.Context, key string, element interface{}) *BoolCmd
        CFAddNX(ctx context.Context, key string, element interface{}) *BoolCmd
        CFCount(ctx context.Context, key string, element interface{}) *IntCmd
        CFDel(ctx context.Context, key string, element interface{}) *BoolCmd
        CFExists(ctx context.Context, key string, element interface{}) *BoolCmd
        CFInfo(ctx context.Context, key string) *CFInfoCmd
        CFInsert(ctx context.Context, key string, options *CFInsertOptions, elements ...interface{}) *BoolSliceCmd
        CFInsertNX(ctx context.Context, key string, options *CFInsertOptions, elements ...interface{}) *IntSliceCmd
        CFMExists(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd
        CFReserve(ctx context.Context, key string, capacity int64) *StatusCmd
        CFReserveWithArgs(ctx context.Context, key string, options *CFReserveOptions) *StatusCmd
        CFReserveExpansion(ctx context.Context, key string, capacity int64, expansion int64) *StatusCmd
        CFReserveBucketSize(ctx context.Context, key string, capacity int64, bucketsize int64) *StatusCmd
        CFReserveMaxIterations(ctx context.Context, key string, capacity int64, maxiterations int64) *StatusCmd
        CFScanDump(ctx context.Context, key string, iterator int64) *ScanDumpCmd
        CFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *StatusCmd

        CMSIncrBy(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd
        CMSInfo(ctx context.Context, key string) *CMSInfoCmd
        CMSInitByDim(ctx context.Context, key string, width, height int64) *StatusCmd
        CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *StatusCmd
        CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *StatusCmd
        CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *StatusCmd
        CMSQuery(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd

        TopKAdd(ctx context.Context, key string, elements ...interface{}) *StringSliceCmd
        TopKCount(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd
        TopKIncrBy(ctx context.Context, key string, elements ...interface{}) *StringSliceCmd
        TopKInfo(ctx context.Context, key string) *TopKInfoCmd
        TopKList(ctx context.Context, key string) *StringSliceCmd
        TopKListWithCount(ctx context.Context, key string) *MapStringIntCmd
        TopKQuery(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd
        TopKReserve(ctx context.Context, key string, k int64) *StatusCmd
        TopKReserveWithOptions(ctx context.Context, key string, k int64, width, depth int64, decay float64) *StatusCmd

        TDigestAdd(ctx context.Context, key string, elements ...float64) *StatusCmd
        TDigestByRank(ctx context.Context, key string, rank ...uint64) *FloatSliceCmd
        TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *FloatSliceCmd
        TDigestCDF(ctx context.Context, key string, elements ...float64) *FloatSliceCmd
        TDigestCreate(ctx context.Context, key string) *StatusCmd
        TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *StatusCmd
        TDigestInfo(ctx context.Context, key string) *TDigestInfoCmd
        TDigestMax(ctx context.Context, key string) *FloatCmd
        TDigestMin(ctx context.Context, key string) *FloatCmd
        TDigestMerge(ctx context.Context, destKey string, options *TDigestMergeOptions, sourceKeys ...string) *StatusCmd
        TDigestQuantile(ctx context.Context, key string, elements ...float64) *FloatSliceCmd
        TDigestRank(ctx context.Context, key string, values ...float64) *IntSliceCmd
        TDigestReset(ctx context.Context, key string) *StatusCmd
        TDigestRevRank(ctx context.Context, key string, values ...float64) *IntSliceCmd
        TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *FloatCmd
}

type BFInsertOptions struct {
        Capacity   int64
        Error      float64
        Expansion  int64
        NonScaling bool
        NoCreate   bool
}

type BFReserveOptions struct {
        Capacity   int64
        Error      float64
        Expansion  int64
        NonScaling bool
}

type CFReserveOptions struct {
        Capacity      int64
        BucketSize    int64
        MaxIterations int64
        Expansion     int64
}

type CFInsertOptions struct {
        Capacity int64
        NoCreate bool
}

// -------------------------------------------
// Bloom filter commands
//-------------------------------------------

// BFReserve creates an empty Bloom filter with a single sub-filter
// for the initial specified capacity and with an upper bound error_rate.
// For more information - https://redis.io/commands/bf.reserve/
func (c cmdable) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *StatusCmd {
        args := []interface{}{"BF.RESERVE", key, errorRate, capacity}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFReserveExpansion creates an empty Bloom filter with a single sub-filter
// for the initial specified capacity and with an upper bound error_rate.
// This function also allows for specifying an expansion rate for the filter.
// For more information - https://redis.io/commands/bf.reserve/
func (c cmdable) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *StatusCmd {
        args := []interface{}{"BF.RESERVE", key, errorRate, capacity, "EXPANSION", expansion}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFReserveNonScaling creates an empty Bloom filter with a single sub-filter
// for the initial specified capacity and with an upper bound error_rate.
// This function also allows for specifying that the filter should not scale.
// For more information - https://redis.io/commands/bf.reserve/
func (c cmdable) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *StatusCmd {
        args := []interface{}{"BF.RESERVE", key, errorRate, capacity, "NONSCALING"}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFReserveWithArgs creates an empty Bloom filter with a single sub-filter
// for the initial specified capacity and with an upper bound error_rate.
// This function also allows for specifying additional options such as expansion rate and non-scaling behavior.
// For more information - https://redis.io/commands/bf.reserve/
func (c cmdable) BFReserveWithArgs(ctx context.Context, key string, options *BFReserveOptions) *StatusCmd {
        args := []interface{}{"BF.RESERVE", key}
        if options != nil {
                args = append(args, options.Error, options.Capacity)
                if options.Expansion != 0 {
                        args = append(args, "EXPANSION", options.Expansion)
                }
                if options.NonScaling {
                        args = append(args, "NONSCALING")
                }
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFAdd adds an item to a Bloom filter.
// For more information - https://redis.io/commands/bf.add/
func (c cmdable) BFAdd(ctx context.Context, key string, element interface{}) *BoolCmd {
        args := []interface{}{"BF.ADD", key, element}
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFCard returns the cardinality of a Bloom filter -
// number of items that were added to a Bloom filter and detected as unique
// (items that caused at least one bit to be set in at least one sub-filter).
// For more information - https://redis.io/commands/bf.card/
func (c cmdable) BFCard(ctx context.Context, key string) *IntCmd {
        args := []interface{}{"BF.CARD", key}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFExists determines whether a given item was added to a Bloom filter.
// For more information - https://redis.io/commands/bf.exists/
func (c cmdable) BFExists(ctx context.Context, key string, element interface{}) *BoolCmd {
        args := []interface{}{"BF.EXISTS", key, element}
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFLoadChunk restores a Bloom filter previously saved using BF.SCANDUMP.
// For more information - https://redis.io/commands/bf.loadchunk/
func (c cmdable) BFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *StatusCmd {
        args := []interface{}{"BF.LOADCHUNK", key, iterator, data}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// Begins an incremental save of the Bloom filter.
// This command is useful for large Bloom filters that cannot fit into the DUMP and RESTORE model.
// For more information - https://redis.io/commands/bf.scandump/
func (c cmdable) BFScanDump(ctx context.Context, key string, iterator int64) *ScanDumpCmd {
        args := []interface{}{"BF.SCANDUMP", key, iterator}
        cmd := newScanDumpCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type ScanDump struct {
        Iter int64
        Data string
}

type ScanDumpCmd struct {
        baseCmd

        val ScanDump
}

func newScanDumpCmd(ctx context.Context, args ...interface{}) *ScanDumpCmd {
        return &ScanDumpCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *ScanDumpCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *ScanDumpCmd) SetVal(val ScanDump) {
        cmd.val = val
}

func (cmd *ScanDumpCmd) Result() (ScanDump, error) {
        return cmd.val, cmd.err
}

func (cmd *ScanDumpCmd) Val() ScanDump {
        return cmd.val
}

func (cmd *ScanDumpCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }
        cmd.val = ScanDump{}
        for i := 0; i < n; i++ {
                iter, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                data, err := rd.ReadString()
                if err != nil {
                        return err
                }
                cmd.val.Data = data
                cmd.val.Iter = iter

        }

        return nil
}

// Returns information about a Bloom filter.
// For more information - https://redis.io/commands/bf.info/
func (c cmdable) BFInfo(ctx context.Context, key string) *BFInfoCmd {
        args := []interface{}{"BF.INFO", key}
        cmd := NewBFInfoCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type BFInfo struct {
        Capacity      int64
        Size          int64
        Filters       int64
        ItemsInserted int64
        ExpansionRate int64
}

type BFInfoCmd struct {
        baseCmd

        val BFInfo
}

func NewBFInfoCmd(ctx context.Context, args ...interface{}) *BFInfoCmd {
        return &BFInfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *BFInfoCmd) SetVal(val BFInfo) {
        cmd.val = val
}

func (cmd *BFInfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *BFInfoCmd) Val() BFInfo {
        return cmd.val
}

func (cmd *BFInfoCmd) Result() (BFInfo, error) {
        return cmd.val, cmd.err
}

func (cmd *BFInfoCmd) readReply(rd *proto.Reader) (err error) {
        result := BFInfo{}

        // Create a mapping from key names to pointers of struct fields
        respMapping := map[string]*int64{
                "Capacity":                 &result.Capacity,
                "CAPACITY":                 &result.Capacity,
                "Size":                     &result.Size,
                "SIZE":                     &result.Size,
                "Number of filters":        &result.Filters,
                "FILTERS":                  &result.Filters,
                "Number of items inserted": &result.ItemsInserted,
                "ITEMS":                    &result.ItemsInserted,
                "Expansion rate":           &result.ExpansionRate,
                "EXPANSION":                &result.ExpansionRate,
        }

        // Helper function to read and assign a value based on the key
        readAndAssignValue := func(key string) error {
                fieldPtr, exists := respMapping[key]
                if !exists {
                        return fmt.Errorf("redis: BLOOM.INFO unexpected key %s", key)
                }

                // Read the integer and assign to the field via pointer dereferencing
                val, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                *fieldPtr = val
                return nil
        }

        readType, err := rd.PeekReplyType()
        if err != nil {
                return err
        }

        if len(cmd.args) > 2 && readType == proto.RespArray {
                n, err := rd.ReadArrayLen()
                if err != nil {
                        return err
                }
                if key, ok := cmd.args[2].(string); ok && n == 1 {
                        if err := readAndAssignValue(key); err != nil {
                                return err
                        }
                } else {
                        return fmt.Errorf("redis: BLOOM.INFO invalid argument key type")
                }
        } else {
                n, err := rd.ReadMapLen()
                if err != nil {
                        return err
                }
                for i := 0; i < n; i++ {
                        key, err := rd.ReadString()
                        if err != nil {
                                return err
                        }
                        if err := readAndAssignValue(key); err != nil {
                                return err
                        }
                }
        }

        cmd.val = result
        return nil
}

// BFInfoCapacity returns information about the capacity of a Bloom filter.
// For more information - https://redis.io/commands/bf.info/
func (c cmdable) BFInfoCapacity(ctx context.Context, key string) *BFInfoCmd {
        return c.BFInfoArg(ctx, key, "CAPACITY")
}

// BFInfoSize returns information about the size of a Bloom filter.
// For more information - https://redis.io/commands/bf.info/
func (c cmdable) BFInfoSize(ctx context.Context, key string) *BFInfoCmd {
        return c.BFInfoArg(ctx, key, "SIZE")
}

// BFInfoFilters returns information about the filters of a Bloom filter.
// For more information - https://redis.io/commands/bf.info/
func (c cmdable) BFInfoFilters(ctx context.Context, key string) *BFInfoCmd {
        return c.BFInfoArg(ctx, key, "FILTERS")
}

// BFInfoItems returns information about the items of a Bloom filter.
// For more information - https://redis.io/commands/bf.info/
func (c cmdable) BFInfoItems(ctx context.Context, key string) *BFInfoCmd {
        return c.BFInfoArg(ctx, key, "ITEMS")
}

// BFInfoExpansion returns information about the expansion rate of a Bloom filter.
// For more information - https://redis.io/commands/bf.info/
func (c cmdable) BFInfoExpansion(ctx context.Context, key string) *BFInfoCmd {
        return c.BFInfoArg(ctx, key, "EXPANSION")
}

// BFInfoArg returns information about a specific option of a Bloom filter.
// For more information - https://redis.io/commands/bf.info/
func (c cmdable) BFInfoArg(ctx context.Context, key, option string) *BFInfoCmd {
        args := []interface{}{"BF.INFO", key, option}
        cmd := NewBFInfoCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFInsert inserts elements into a Bloom filter.
// This function also allows for specifying additional options such as:
// capacity, error rate, expansion rate, and non-scaling behavior.
// For more information - https://redis.io/commands/bf.insert/
func (c cmdable) BFInsert(ctx context.Context, key string, options *BFInsertOptions, elements ...interface{}) *BoolSliceCmd {
        args := []interface{}{"BF.INSERT", key}
        if options != nil {
                if options.Capacity != 0 {
                        args = append(args, "CAPACITY", options.Capacity)
                }
                if options.Error != 0 {
                        args = append(args, "ERROR", options.Error)
                }
                if options.Expansion != 0 {
                        args = append(args, "EXPANSION", options.Expansion)
                }
                if options.NoCreate {
                        args = append(args, "NOCREATE")
                }
                if options.NonScaling {
                        args = append(args, "NONSCALING")
                }
        }
        args = append(args, "ITEMS")
        args = append(args, elements...)

        cmd := NewBoolSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFMAdd adds multiple elements to a Bloom filter.
// Returns an array of booleans indicating whether each element was added to the filter or not.
// For more information - https://redis.io/commands/bf.madd/
func (c cmdable) BFMAdd(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd {
        args := []interface{}{"BF.MADD", key}
        args = append(args, elements...)
        cmd := NewBoolSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// BFMExists check if multiple elements exist in a Bloom filter.
// Returns an array of booleans indicating whether each element exists in the filter or not.
// For more information - https://redis.io/commands/bf.mexists/
func (c cmdable) BFMExists(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd {
        args := []interface{}{"BF.MEXISTS", key}
        args = append(args, elements...)

        cmd := NewBoolSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// -------------------------------------------
// Cuckoo filter commands
//-------------------------------------------

// CFReserve creates an empty Cuckoo filter with the specified capacity.
// For more information - https://redis.io/commands/cf.reserve/
func (c cmdable) CFReserve(ctx context.Context, key string, capacity int64) *StatusCmd {
        args := []interface{}{"CF.RESERVE", key, capacity}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFReserveExpansion creates an empty Cuckoo filter with the specified capacity and expansion rate.
// For more information - https://redis.io/commands/cf.reserve/
func (c cmdable) CFReserveExpansion(ctx context.Context, key string, capacity int64, expansion int64) *StatusCmd {
        args := []interface{}{"CF.RESERVE", key, capacity, "EXPANSION", expansion}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFReserveBucketSize creates an empty Cuckoo filter with the specified capacity and bucket size.
// For more information - https://redis.io/commands/cf.reserve/
func (c cmdable) CFReserveBucketSize(ctx context.Context, key string, capacity int64, bucketsize int64) *StatusCmd {
        args := []interface{}{"CF.RESERVE", key, capacity, "BUCKETSIZE", bucketsize}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFReserveMaxIterations creates an empty Cuckoo filter with the specified capacity and maximum number of iterations.
// For more information - https://redis.io/commands/cf.reserve/
func (c cmdable) CFReserveMaxIterations(ctx context.Context, key string, capacity int64, maxiterations int64) *StatusCmd {
        args := []interface{}{"CF.RESERVE", key, capacity, "MAXITERATIONS", maxiterations}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFReserveWithArgs creates an empty Cuckoo filter with the specified options.
// This function allows for specifying additional options such as bucket size and maximum number of iterations.
// For more information - https://redis.io/commands/cf.reserve/
func (c cmdable) CFReserveWithArgs(ctx context.Context, key string, options *CFReserveOptions) *StatusCmd {
        args := []interface{}{"CF.RESERVE", key, options.Capacity}
        if options.BucketSize != 0 {
                args = append(args, "BUCKETSIZE", options.BucketSize)
        }
        if options.MaxIterations != 0 {
                args = append(args, "MAXITERATIONS", options.MaxIterations)
        }
        if options.Expansion != 0 {
                args = append(args, "EXPANSION", options.Expansion)
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFAdd adds an element to a Cuckoo filter.
// Returns true if the element was added to the filter or false if it already exists in the filter.
// For more information - https://redis.io/commands/cf.add/
func (c cmdable) CFAdd(ctx context.Context, key string, element interface{}) *BoolCmd {
        args := []interface{}{"CF.ADD", key, element}
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFAddNX adds an element to a Cuckoo filter only if it does not already exist in the filter.
// Returns true if the element was added to the filter or false if it already exists in the filter.
// For more information - https://redis.io/commands/cf.addnx/
func (c cmdable) CFAddNX(ctx context.Context, key string, element interface{}) *BoolCmd {
        args := []interface{}{"CF.ADDNX", key, element}
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFCount returns an estimate of the number of times an element may be in a Cuckoo Filter.
// For more information - https://redis.io/commands/cf.count/
func (c cmdable) CFCount(ctx context.Context, key string, element interface{}) *IntCmd {
        args := []interface{}{"CF.COUNT", key, element}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFDel deletes an item once from the cuckoo filter.
// For more information - https://redis.io/commands/cf.del/
func (c cmdable) CFDel(ctx context.Context, key string, element interface{}) *BoolCmd {
        args := []interface{}{"CF.DEL", key, element}
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFExists determines whether an item may exist in the Cuckoo Filter or not.
// For more information - https://redis.io/commands/cf.exists/
func (c cmdable) CFExists(ctx context.Context, key string, element interface{}) *BoolCmd {
        args := []interface{}{"CF.EXISTS", key, element}
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFLoadChunk restores a filter previously saved using SCANDUMP.
// For more information - https://redis.io/commands/cf.loadchunk/
func (c cmdable) CFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *StatusCmd {
        args := []interface{}{"CF.LOADCHUNK", key, iterator, data}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFScanDump begins an incremental save of the cuckoo filter.
// For more information - https://redis.io/commands/cf.scandump/
func (c cmdable) CFScanDump(ctx context.Context, key string, iterator int64) *ScanDumpCmd {
        args := []interface{}{"CF.SCANDUMP", key, iterator}
        cmd := newScanDumpCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type CFInfo struct {
        Size             int64
        NumBuckets       int64
        NumFilters       int64
        NumItemsInserted int64
        NumItemsDeleted  int64
        BucketSize       int64
        ExpansionRate    int64
        MaxIteration     int64
}

type CFInfoCmd struct {
        baseCmd

        val CFInfo
}

func NewCFInfoCmd(ctx context.Context, args ...interface{}) *CFInfoCmd {
        return &CFInfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *CFInfoCmd) SetVal(val CFInfo) {
        cmd.val = val
}

func (cmd *CFInfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *CFInfoCmd) Val() CFInfo {
        return cmd.val
}

func (cmd *CFInfoCmd) Result() (CFInfo, error) {
        return cmd.val, cmd.err
}

func (cmd *CFInfoCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        var key string
        var result CFInfo
        for f := 0; f < n; f++ {
                key, err = rd.ReadString()
                if err != nil {
                        return err
                }

                switch key {
                case "Size":
                        result.Size, err = rd.ReadInt()
                case "Number of buckets":
                        result.NumBuckets, err = rd.ReadInt()
                case "Number of filters":
                        result.NumFilters, err = rd.ReadInt()
                case "Number of items inserted":
                        result.NumItemsInserted, err = rd.ReadInt()
                case "Number of items deleted":
                        result.NumItemsDeleted, err = rd.ReadInt()
                case "Bucket size":
                        result.BucketSize, err = rd.ReadInt()
                case "Expansion rate":
                        result.ExpansionRate, err = rd.ReadInt()
                case "Max iterations":
                        result.MaxIteration, err = rd.ReadInt()

                default:
                        return fmt.Errorf("redis: CF.INFO unexpected key %s", key)
                }

                if err != nil {
                        return err
                }
        }

        cmd.val = result
        return nil
}

// CFInfo returns information about a Cuckoo filter.
// For more information - https://redis.io/commands/cf.info/
func (c cmdable) CFInfo(ctx context.Context, key string) *CFInfoCmd {
        args := []interface{}{"CF.INFO", key}
        cmd := NewCFInfoCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFInsert inserts elements into a Cuckoo filter.
// This function also allows for specifying additional options such as capacity, error rate, expansion rate, and non-scaling behavior.
// Returns an array of booleans indicating whether each element was added to the filter or not.
// For more information - https://redis.io/commands/cf.insert/
func (c cmdable) CFInsert(ctx context.Context, key string, options *CFInsertOptions, elements ...interface{}) *BoolSliceCmd {
        args := []interface{}{"CF.INSERT", key}
        args = c.getCfInsertWithArgs(args, options, elements...)

        cmd := NewBoolSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CFInsertNX inserts elements into a Cuckoo filter only if they do not already exist in the filter.
// This function also allows for specifying additional options such as:
// capacity, error rate, expansion rate, and non-scaling behavior.
// Returns an array of integers indicating whether each element was added to the filter or not.
// For more information - https://redis.io/commands/cf.insertnx/
func (c cmdable) CFInsertNX(ctx context.Context, key string, options *CFInsertOptions, elements ...interface{}) *IntSliceCmd {
        args := []interface{}{"CF.INSERTNX", key}
        args = c.getCfInsertWithArgs(args, options, elements...)

        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) getCfInsertWithArgs(args []interface{}, options *CFInsertOptions, elements ...interface{}) []interface{} {
        if options != nil {
                if options.Capacity != 0 {
                        args = append(args, "CAPACITY", options.Capacity)
                }
                if options.NoCreate {
                        args = append(args, "NOCREATE")
                }
        }
        args = append(args, "ITEMS")
        args = append(args, elements...)

        return args
}

// CFMExists check if multiple elements exist in a Cuckoo filter.
// Returns an array of booleans indicating whether each element exists in the filter or not.
// For more information - https://redis.io/commands/cf.mexists/
func (c cmdable) CFMExists(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd {
        args := []interface{}{"CF.MEXISTS", key}
        args = append(args, elements...)
        cmd := NewBoolSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// -------------------------------------------
// CMS commands
//-------------------------------------------

// CMSIncrBy increments the count of one or more items in a Count-Min Sketch filter.
// Returns an array of integers representing the updated count of each item.
// For more information - https://redis.io/commands/cms.incrby/
func (c cmdable) CMSIncrBy(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd {
        args := make([]interface{}, 2, 2+len(elements))
        args[0] = "CMS.INCRBY"
        args[1] = key
        args = appendArgs(args, elements)

        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type CMSInfo struct {
        Width int64
        Depth int64
        Count int64
}

type CMSInfoCmd struct {
        baseCmd

        val CMSInfo
}

func NewCMSInfoCmd(ctx context.Context, args ...interface{}) *CMSInfoCmd {
        return &CMSInfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *CMSInfoCmd) SetVal(val CMSInfo) {
        cmd.val = val
}

func (cmd *CMSInfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *CMSInfoCmd) Val() CMSInfo {
        return cmd.val
}

func (cmd *CMSInfoCmd) Result() (CMSInfo, error) {
        return cmd.val, cmd.err
}

func (cmd *CMSInfoCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        var key string
        var result CMSInfo
        for f := 0; f < n; f++ {
                key, err = rd.ReadString()
                if err != nil {
                        return err
                }

                switch key {
                case "width":
                        result.Width, err = rd.ReadInt()
                case "depth":
                        result.Depth, err = rd.ReadInt()
                case "count":
                        result.Count, err = rd.ReadInt()
                default:
                        return fmt.Errorf("redis: CMS.INFO unexpected key %s", key)
                }

                if err != nil {
                        return err
                }
        }

        cmd.val = result
        return nil
}

// CMSInfo returns information about a Count-Min Sketch filter.
// For more information - https://redis.io/commands/cms.info/
func (c cmdable) CMSInfo(ctx context.Context, key string) *CMSInfoCmd {
        args := []interface{}{"CMS.INFO", key}
        cmd := NewCMSInfoCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CMSInitByDim creates an empty Count-Min Sketch filter with the specified dimensions.
// For more information - https://redis.io/commands/cms.initbydim/
func (c cmdable) CMSInitByDim(ctx context.Context, key string, width, depth int64) *StatusCmd {
        args := []interface{}{"CMS.INITBYDIM", key, width, depth}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CMSInitByProb creates an empty Count-Min Sketch filter with the specified error rate and probability.
// For more information - https://redis.io/commands/cms.initbyprob/
func (c cmdable) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *StatusCmd {
        args := []interface{}{"CMS.INITBYPROB", key, errorRate, probability}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CMSMerge merges multiple Count-Min Sketch filters into a single filter.
// The destination filter must not exist and will be created with the dimensions of the first source filter.
// The number of items in each source filter must be equal.
// Returns OK on success or an error if the filters could not be merged.
// For more information - https://redis.io/commands/cms.merge/
func (c cmdable) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *StatusCmd {
        args := []interface{}{"CMS.MERGE", destKey, len(sourceKeys)}
        for _, s := range sourceKeys {
                args = append(args, s)
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CMSMergeWithWeight merges multiple Count-Min Sketch filters into a single filter with weights for each source filter.
// The destination filter must not exist and will be created with the dimensions of the first source filter.
// The number of items in each source filter must be equal.
// Returns OK on success or an error if the filters could not be merged.
// For more information - https://redis.io/commands/cms.merge/
func (c cmdable) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *StatusCmd {
        args := make([]interface{}, 0, 4+(len(sourceKeys)*2+1))
        args = append(args, "CMS.MERGE", destKey, len(sourceKeys))

        if len(sourceKeys) > 0 {
                sk := make([]interface{}, len(sourceKeys))
                sw := make([]interface{}, len(sourceKeys))

                i := 0
                for k, w := range sourceKeys {
                        sk[i] = k
                        sw[i] = w
                        i++
                }

                args = append(args, sk...)
                args = append(args, "WEIGHTS")
                args = append(args, sw...)
        }

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// CMSQuery returns count for item(s).
// For more information - https://redis.io/commands/cms.query/
func (c cmdable) CMSQuery(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd {
        args := []interface{}{"CMS.QUERY", key}
        args = append(args, elements...)
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// -------------------------------------------
// TopK commands
//--------------------------------------------

// TopKAdd adds one or more elements to a Top-K filter.
// Returns an array of strings representing the items that were removed from the filter, if any.
// For more information - https://redis.io/commands/topk.add/
func (c cmdable) TopKAdd(ctx context.Context, key string, elements ...interface{}) *StringSliceCmd {
        args := make([]interface{}, 2, 2+len(elements))
        args[0] = "TOPK.ADD"
        args[1] = key
        args = appendArgs(args, elements)

        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TopKReserve creates an empty Top-K filter with the specified number of top items to keep.
// For more information - https://redis.io/commands/topk.reserve/
func (c cmdable) TopKReserve(ctx context.Context, key string, k int64) *StatusCmd {
        args := []interface{}{"TOPK.RESERVE", key, k}

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TopKReserveWithOptions creates an empty Top-K filter with the specified number of top items to keep and additional options.
// This function allows for specifying additional options such as width, depth and decay.
// For more information - https://redis.io/commands/topk.reserve/
func (c cmdable) TopKReserveWithOptions(ctx context.Context, key string, k int64, width, depth int64, decay float64) *StatusCmd {
        args := []interface{}{"TOPK.RESERVE", key, k, width, depth, decay}

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type TopKInfo struct {
        K     int64
        Width int64
        Depth int64
        Decay float64
}

type TopKInfoCmd struct {
        baseCmd

        val TopKInfo
}

func NewTopKInfoCmd(ctx context.Context, args ...interface{}) *TopKInfoCmd {
        return &TopKInfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *TopKInfoCmd) SetVal(val TopKInfo) {
        cmd.val = val
}

func (cmd *TopKInfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *TopKInfoCmd) Val() TopKInfo {
        return cmd.val
}

func (cmd *TopKInfoCmd) Result() (TopKInfo, error) {
        return cmd.val, cmd.err
}

func (cmd *TopKInfoCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        var key string
        var result TopKInfo
        for f := 0; f < n; f++ {
                key, err = rd.ReadString()
                if err != nil {
                        return err
                }

                switch key {
                case "k":
                        result.K, err = rd.ReadInt()
                case "width":
                        result.Width, err = rd.ReadInt()
                case "depth":
                        result.Depth, err = rd.ReadInt()
                case "decay":
                        result.Decay, err = rd.ReadFloat()
                default:
                        return fmt.Errorf("redis: topk.info unexpected key %s", key)
                }

                if err != nil {
                        return err
                }
        }

        cmd.val = result
        return nil
}

// TopKInfo returns information about a Top-K filter.
// For more information - https://redis.io/commands/topk.info/
func (c cmdable) TopKInfo(ctx context.Context, key string) *TopKInfoCmd {
        args := []interface{}{"TOPK.INFO", key}

        cmd := NewTopKInfoCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TopKQuery check if multiple elements exist in a Top-K filter.
// Returns an array of booleans indicating whether each element exists in the filter or not.
// For more information - https://redis.io/commands/topk.query/
func (c cmdable) TopKQuery(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd {
        args := make([]interface{}, 2, 2+len(elements))
        args[0] = "TOPK.QUERY"
        args[1] = key
        args = appendArgs(args, elements)

        cmd := NewBoolSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TopKCount returns an estimate of the number of times an item may be in a Top-K filter.
// For more information - https://redis.io/commands/topk.count/
func (c cmdable) TopKCount(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd {
        args := make([]interface{}, 2, 2+len(elements))
        args[0] = "TOPK.COUNT"
        args[1] = key
        args = appendArgs(args, elements)

        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TopKIncrBy increases the count of one or more items in a Top-K filter.
// For more information - https://redis.io/commands/topk.incrby/
func (c cmdable) TopKIncrBy(ctx context.Context, key string, elements ...interface{}) *StringSliceCmd {
        args := make([]interface{}, 2, 2+len(elements))
        args[0] = "TOPK.INCRBY"
        args[1] = key
        args = appendArgs(args, elements)

        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TopKList returns all items in Top-K list.
// For more information - https://redis.io/commands/topk.list/
func (c cmdable) TopKList(ctx context.Context, key string) *StringSliceCmd {
        args := []interface{}{"TOPK.LIST", key}

        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TopKListWithCount returns all items in Top-K list with their respective count.
// For more information - https://redis.io/commands/topk.list/
func (c cmdable) TopKListWithCount(ctx context.Context, key string) *MapStringIntCmd {
        args := []interface{}{"TOPK.LIST", key, "WITHCOUNT"}

        cmd := NewMapStringIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// -------------------------------------------
// t-digest commands
// --------------------------------------------

// TDigestAdd adds one or more elements to a t-Digest data structure.
// Returns OK on success or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.add/
func (c cmdable) TDigestAdd(ctx context.Context, key string, elements ...float64) *StatusCmd {
        args := make([]interface{}, 2+len(elements))
        args[0] = "TDIGEST.ADD"
        args[1] = key

        for i, v := range elements {
                args[2+i] = v
        }

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestByRank returns an array of values from a t-Digest data structure based on their rank.
// The rank of an element is its position in the sorted list of all elements in the t-Digest.
// Returns an array of floats representing the values at the specified ranks or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.byrank/
func (c cmdable) TDigestByRank(ctx context.Context, key string, rank ...uint64) *FloatSliceCmd {
        args := make([]interface{}, 2+len(rank))
        args[0] = "TDIGEST.BYRANK"
        args[1] = key

        for i, r := range rank {
                args[2+i] = r
        }

        cmd := NewFloatSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestByRevRank returns an array of values from a t-Digest data structure based on their reverse rank.
// The reverse rank of an element is its position in the sorted list of all elements in the t-Digest when sorted in descending order.
// Returns an array of floats representing the values at the specified ranks or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.byrevrank/
func (c cmdable) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *FloatSliceCmd {
        args := make([]interface{}, 2+len(rank))
        args[0] = "TDIGEST.BYREVRANK"
        args[1] = key

        for i, r := range rank {
                args[2+i] = r
        }

        cmd := NewFloatSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestCDF returns an array of cumulative distribution function (CDF) values for one or more elements in a t-Digest data structure.
// The CDF value for an element is the fraction of all elements in the t-Digest that are less than or equal to it.
// Returns an array of floats representing the CDF values for each element or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.cdf/
func (c cmdable) TDigestCDF(ctx context.Context, key string, elements ...float64) *FloatSliceCmd {
        args := make([]interface{}, 2+len(elements))
        args[0] = "TDIGEST.CDF"
        args[1] = key

        for i, v := range elements {
                args[2+i] = v
        }

        cmd := NewFloatSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestCreate creates an empty t-Digest data structure with default parameters.
// Returns OK on success or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.create/
func (c cmdable) TDigestCreate(ctx context.Context, key string) *StatusCmd {
        args := []interface{}{"TDIGEST.CREATE", key}

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestCreateWithCompression creates an empty t-Digest data structure with a specified compression parameter.
// The compression parameter controls the accuracy and memory usage of the t-Digest.
// Returns OK on success or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.create/
func (c cmdable) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *StatusCmd {
        args := []interface{}{"TDIGEST.CREATE", key, "COMPRESSION", compression}

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type TDigestInfo struct {
        Compression       int64
        Capacity          int64
        MergedNodes       int64
        UnmergedNodes     int64
        MergedWeight      int64
        UnmergedWeight    int64
        Observations      int64
        TotalCompressions int64
        MemoryUsage       int64
}

type TDigestInfoCmd struct {
        baseCmd

        val TDigestInfo
}

func NewTDigestInfoCmd(ctx context.Context, args ...interface{}) *TDigestInfoCmd {
        return &TDigestInfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *TDigestInfoCmd) SetVal(val TDigestInfo) {
        cmd.val = val
}

func (cmd *TDigestInfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *TDigestInfoCmd) Val() TDigestInfo {
        return cmd.val
}

func (cmd *TDigestInfoCmd) Result() (TDigestInfo, error) {
        return cmd.val, cmd.err
}

func (cmd *TDigestInfoCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        var key string
        var result TDigestInfo
        for f := 0; f < n; f++ {
                key, err = rd.ReadString()
                if err != nil {
                        return err
                }

                switch key {
                case "Compression":
                        result.Compression, err = rd.ReadInt()
                case "Capacity":
                        result.Capacity, err = rd.ReadInt()
                case "Merged nodes":
                        result.MergedNodes, err = rd.ReadInt()
                case "Unmerged nodes":
                        result.UnmergedNodes, err = rd.ReadInt()
                case "Merged weight":
                        result.MergedWeight, err = rd.ReadInt()
                case "Unmerged weight":
                        result.UnmergedWeight, err = rd.ReadInt()
                case "Observations":
                        result.Observations, err = rd.ReadInt()
                case "Total compressions":
                        result.TotalCompressions, err = rd.ReadInt()
                case "Memory usage":
                        result.MemoryUsage, err = rd.ReadInt()
                default:
                        return fmt.Errorf("redis: tdigest.info unexpected key %s", key)
                }

                if err != nil {
                        return err
                }
        }

        cmd.val = result
        return nil
}

// TDigestInfo returns information about a t-Digest data structure.
// For more information - https://redis.io/commands/tdigest.info/
func (c cmdable) TDigestInfo(ctx context.Context, key string) *TDigestInfoCmd {
        args := []interface{}{"TDIGEST.INFO", key}

        cmd := NewTDigestInfoCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestMax returns the maximum value from a t-Digest data structure.
// For more information - https://redis.io/commands/tdigest.max/
func (c cmdable) TDigestMax(ctx context.Context, key string) *FloatCmd {
        args := []interface{}{"TDIGEST.MAX", key}

        cmd := NewFloatCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type TDigestMergeOptions struct {
        Compression int64
        Override    bool
}

// TDigestMerge merges multiple t-Digest data structures into a single t-Digest.
// This function also allows for specifying additional options such as compression and override behavior.
// Returns OK on success or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.merge/
func (c cmdable) TDigestMerge(ctx context.Context, destKey string, options *TDigestMergeOptions, sourceKeys ...string) *StatusCmd {
        args := []interface{}{"TDIGEST.MERGE", destKey, len(sourceKeys)}

        for _, sourceKey := range sourceKeys {
                args = append(args, sourceKey)
        }

        if options != nil {
                if options.Compression != 0 {
                        args = append(args, "COMPRESSION", options.Compression)
                }
                if options.Override {
                        args = append(args, "OVERRIDE")
                }
        }

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestMin returns the minimum value from a t-Digest data structure.
// For more information - https://redis.io/commands/tdigest.min/
func (c cmdable) TDigestMin(ctx context.Context, key string) *FloatCmd {
        args := []interface{}{"TDIGEST.MIN", key}

        cmd := NewFloatCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestQuantile returns an array of quantile values for one or more elements in a t-Digest data structure.
// The quantile value for an element is the fraction of all elements in the t-Digest that are less than or equal to it.
// Returns an array of floats representing the quantile values for each element or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.quantile/
func (c cmdable) TDigestQuantile(ctx context.Context, key string, elements ...float64) *FloatSliceCmd {
        args := make([]interface{}, 2+len(elements))
        args[0] = "TDIGEST.QUANTILE"
        args[1] = key

        for i, v := range elements {
                args[2+i] = v
        }

        cmd := NewFloatSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestRank returns an array of rank values for one or more elements in a t-Digest data structure.
// The rank of an element is its position in the sorted list of all elements in the t-Digest.
// Returns an array of integers representing the rank values for each element or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.rank/
func (c cmdable) TDigestRank(ctx context.Context, key string, values ...float64) *IntSliceCmd {
        args := make([]interface{}, 2+len(values))
        args[0] = "TDIGEST.RANK"
        args[1] = key

        for i, v := range values {
                args[i+2] = v
        }

        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestReset resets a t-Digest data structure to its initial state.
// Returns OK on success or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.reset/
func (c cmdable) TDigestReset(ctx context.Context, key string) *StatusCmd {
        args := []interface{}{"TDIGEST.RESET", key}

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestRevRank returns an array of reverse rank values for one or more elements in a t-Digest data structure.
// The reverse rank of an element is its position in the sorted list of all elements in the t-Digest when sorted in descending order.
// Returns an array of integers representing the reverse rank values for each element or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.revrank/
func (c cmdable) TDigestRevRank(ctx context.Context, key string, values ...float64) *IntSliceCmd {
        args := make([]interface{}, 2+len(values))
        args[0] = "TDIGEST.REVRANK"
        args[1] = key

        for i, v := range values {
                args[2+i] = v
        }

        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TDigestTrimmedMean returns the trimmed mean value from a t-Digest data structure.
// The trimmed mean is calculated by removing a specified fraction of the highest and lowest values from the t-Digest and then calculating the mean of the remaining values.
// Returns a float representing the trimmed mean value or an error if the operation could not be completed.
// For more information - https://redis.io/commands/tdigest.trimmed_mean/
func (c cmdable) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *FloatCmd {
        args := []interface{}{"TDIGEST.TRIMMED_MEAN", key, lowCutQuantile, highCutQuantile}

        cmd := NewFloatCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "fmt"
        "strings"
        "sync"
        "time"

        "github.com/redis/go-redis/v9/internal"
        "github.com/redis/go-redis/v9/internal/pool"
        "github.com/redis/go-redis/v9/internal/proto"
)

// PubSub implements Pub/Sub commands as described in
// http://redis.io/topics/pubsub. Message receiving is NOT safe
// for concurrent use by multiple goroutines.
//
// PubSub automatically reconnects to Redis Server and resubscribes
// to the channels in case of network errors.
type PubSub struct {
        opt *Options

        newConn   func(ctx context.Context, channels []string) (*pool.Conn, error)
        closeConn func(*pool.Conn) error

        mu        sync.Mutex
        cn        *pool.Conn
        channels  map[string]struct{}
        patterns  map[string]struct{}
        schannels map[string]struct{}

        closed bool
        exit   chan struct{}

        cmd *Cmd

        chOnce sync.Once
        msgCh  *channel
        allCh  *channel
}

func (c *PubSub) init() {
        c.exit = make(chan struct{})
}

func (c *PubSub) String() string {
        c.mu.Lock()
        defer c.mu.Unlock()

        channels := mapKeys(c.channels)
        channels = append(channels, mapKeys(c.patterns)...)
        channels = append(channels, mapKeys(c.schannels)...)
        return fmt.Sprintf("PubSub(%s)", strings.Join(channels, ", "))
}

func (c *PubSub) connWithLock(ctx context.Context) (*pool.Conn, error) {
        c.mu.Lock()
        cn, err := c.conn(ctx, nil)
        c.mu.Unlock()
        return cn, err
}

func (c *PubSub) conn(ctx context.Context, newChannels []string) (*pool.Conn, error) {
        if c.closed {
                return nil, pool.ErrClosed
        }
        if c.cn != nil {
                return c.cn, nil
        }

        channels := mapKeys(c.channels)
        channels = append(channels, newChannels...)

        cn, err := c.newConn(ctx, channels)
        if err != nil {
                return nil, err
        }

        if err := c.resubscribe(ctx, cn); err != nil {
                _ = c.closeConn(cn)
                return nil, err
        }

        c.cn = cn
        return cn, nil
}

func (c *PubSub) writeCmd(ctx context.Context, cn *pool.Conn, cmd Cmder) error {
        return cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
                return writeCmd(wr, cmd)
        })
}

func (c *PubSub) resubscribe(ctx context.Context, cn *pool.Conn) error {
        var firstErr error

        if len(c.channels) > 0 {
                firstErr = c._subscribe(ctx, cn, "subscribe", mapKeys(c.channels))
        }

        if len(c.patterns) > 0 {
                err := c._subscribe(ctx, cn, "psubscribe", mapKeys(c.patterns))
                if err != nil && firstErr == nil {
                        firstErr = err
                }
        }

        if len(c.schannels) > 0 {
                err := c._subscribe(ctx, cn, "ssubscribe", mapKeys(c.schannels))
                if err != nil && firstErr == nil {
                        firstErr = err
                }
        }

        return firstErr
}

func mapKeys(m map[string]struct{}) []string {
        s := make([]string, len(m))
        i := 0
        for k := range m {
                s[i] = k
                i++
        }
        return s
}

func (c *PubSub) _subscribe(
        ctx context.Context, cn *pool.Conn, redisCmd string, channels []string,
) error {
        args := make([]interface{}, 0, 1+len(channels))
        args = append(args, redisCmd)
        for _, channel := range channels {
                args = append(args, channel)
        }
        cmd := NewSliceCmd(ctx, args...)
        return c.writeCmd(ctx, cn, cmd)
}

func (c *PubSub) releaseConnWithLock(
        ctx context.Context,
        cn *pool.Conn,
        err error,
        allowTimeout bool,
) {
        c.mu.Lock()
        c.releaseConn(ctx, cn, err, allowTimeout)
        c.mu.Unlock()
}

func (c *PubSub) releaseConn(ctx context.Context, cn *pool.Conn, err error, allowTimeout bool) {
        if c.cn != cn {
                return
        }
        if isBadConn(err, allowTimeout, c.opt.Addr) {
                c.reconnect(ctx, err)
        }
}

func (c *PubSub) reconnect(ctx context.Context, reason error) {
        _ = c.closeTheCn(reason)
        _, _ = c.conn(ctx, nil)
}

func (c *PubSub) closeTheCn(reason error) error {
        if c.cn == nil {
                return nil
        }
        if !c.closed {
                internal.Logger.Printf(c.getContext(), "redis: discarding bad PubSub connection: %s", reason)
        }
        err := c.closeConn(c.cn)
        c.cn = nil
        return err
}

func (c *PubSub) Close() error {
        c.mu.Lock()
        defer c.mu.Unlock()

        if c.closed {
                return pool.ErrClosed
        }
        c.closed = true
        close(c.exit)

        return c.closeTheCn(pool.ErrClosed)
}

// Subscribe the client to the specified channels. It returns
// empty subscription if there are no channels.
func (c *PubSub) Subscribe(ctx context.Context, channels ...string) error {
        c.mu.Lock()
        defer c.mu.Unlock()

        err := c.subscribe(ctx, "subscribe", channels...)
        if c.channels == nil {
                c.channels = make(map[string]struct{})
        }
        for _, s := range channels {
                c.channels[s] = struct{}{}
        }
        return err
}

// PSubscribe the client to the given patterns. It returns
// empty subscription if there are no patterns.
func (c *PubSub) PSubscribe(ctx context.Context, patterns ...string) error {
        c.mu.Lock()
        defer c.mu.Unlock()

        err := c.subscribe(ctx, "psubscribe", patterns...)
        if c.patterns == nil {
                c.patterns = make(map[string]struct{})
        }
        for _, s := range patterns {
                c.patterns[s] = struct{}{}
        }
        return err
}

// SSubscribe Subscribes the client to the specified shard channels.
func (c *PubSub) SSubscribe(ctx context.Context, channels ...string) error {
        c.mu.Lock()
        defer c.mu.Unlock()

        err := c.subscribe(ctx, "ssubscribe", channels...)
        if c.schannels == nil {
                c.schannels = make(map[string]struct{})
        }
        for _, s := range channels {
                c.schannels[s] = struct{}{}
        }
        return err
}

// Unsubscribe the client from the given channels, or from all of
// them if none is given.
func (c *PubSub) Unsubscribe(ctx context.Context, channels ...string) error {
        c.mu.Lock()
        defer c.mu.Unlock()

        if len(channels) > 0 {
                for _, channel := range channels {
                        delete(c.channels, channel)
                }
        } else {
                // Unsubscribe from all channels.
                for channel := range c.channels {
                        delete(c.channels, channel)
                }
        }

        err := c.subscribe(ctx, "unsubscribe", channels...)
        return err
}

// PUnsubscribe the client from the given patterns, or from all of
// them if none is given.
func (c *PubSub) PUnsubscribe(ctx context.Context, patterns ...string) error {
        c.mu.Lock()
        defer c.mu.Unlock()

        if len(patterns) > 0 {
                for _, pattern := range patterns {
                        delete(c.patterns, pattern)
                }
        } else {
                // Unsubscribe from all patterns.
                for pattern := range c.patterns {
                        delete(c.patterns, pattern)
                }
        }

        err := c.subscribe(ctx, "punsubscribe", patterns...)
        return err
}

// SUnsubscribe unsubscribes the client from the given shard channels,
// or from all of them if none is given.
func (c *PubSub) SUnsubscribe(ctx context.Context, channels ...string) error {
        c.mu.Lock()
        defer c.mu.Unlock()

        if len(channels) > 0 {
                for _, channel := range channels {
                        delete(c.schannels, channel)
                }
        } else {
                // Unsubscribe from all channels.
                for channel := range c.schannels {
                        delete(c.schannels, channel)
                }
        }

        err := c.subscribe(ctx, "sunsubscribe", channels...)
        return err
}

func (c *PubSub) subscribe(ctx context.Context, redisCmd string, channels ...string) error {
        cn, err := c.conn(ctx, channels)
        if err != nil {
                return err
        }

        err = c._subscribe(ctx, cn, redisCmd, channels)
        c.releaseConn(ctx, cn, err, false)
        return err
}

func (c *PubSub) Ping(ctx context.Context, payload ...string) error {
        args := []interface{}{"ping"}
        if len(payload) == 1 {
                args = append(args, payload[0])
        }
        cmd := NewCmd(ctx, args...)

        c.mu.Lock()
        defer c.mu.Unlock()

        cn, err := c.conn(ctx, nil)
        if err != nil {
                return err
        }

        err = c.writeCmd(ctx, cn, cmd)
        c.releaseConn(ctx, cn, err, false)
        return err
}

// Subscription received after a successful subscription to channel.
type Subscription struct {
        // Can be "subscribe", "unsubscribe", "psubscribe" or "punsubscribe".
        Kind string
        // Channel name we have subscribed to.
        Channel string
        // Number of channels we are currently subscribed to.
        Count int
}

func (m *Subscription) String() string {
        return fmt.Sprintf("%s: %s", m.Kind, m.Channel)
}

// Message received as result of a PUBLISH command issued by another client.
type Message struct {
        Channel      string
        Pattern      string
        Payload      string
        PayloadSlice []string
}

func (m *Message) String() string {
        return fmt.Sprintf("Message<%s: %s>", m.Channel, m.Payload)
}

// Pong received as result of a PING command issued by another client.
type Pong struct {
        Payload string
}

func (p *Pong) String() string {
        if p.Payload != "" {
                return fmt.Sprintf("Pong<%s>", p.Payload)
        }
        return "Pong"
}

func (c *PubSub) newMessage(reply interface{}) (interface{}, error) {
        switch reply := reply.(type) {
        case string:
                return &Pong{
                        Payload: reply,
                }, nil
        case []interface{}:
                switch kind := reply[0].(string); kind {
                case "subscribe", "unsubscribe", "psubscribe", "punsubscribe", "ssubscribe", "sunsubscribe":
                        // Can be nil in case of "unsubscribe".
                        channel, _ := reply[1].(string)
                        return &Subscription{
                                Kind:    kind,
                                Channel: channel,
                                Count:   int(reply[2].(int64)),
                        }, nil
                case "message", "smessage":
                        switch payload := reply[2].(type) {
                        case string:
                                return &Message{
                                        Channel: reply[1].(string),
                                        Payload: payload,
                                }, nil
                        case []interface{}:
                                ss := make([]string, len(payload))
                                for i, s := range payload {
                                        ss[i] = s.(string)
                                }
                                return &Message{
                                        Channel:      reply[1].(string),
                                        PayloadSlice: ss,
                                }, nil
                        default:
                                return nil, fmt.Errorf("redis: unsupported pubsub message payload: %T", payload)
                        }
                case "pmessage":
                        return &Message{
                                Pattern: reply[1].(string),
                                Channel: reply[2].(string),
                                Payload: reply[3].(string),
                        }, nil
                case "pong":
                        return &Pong{
                                Payload: reply[1].(string),
                        }, nil
                default:
                        return nil, fmt.Errorf("redis: unsupported pubsub message: %q", kind)
                }
        default:
                return nil, fmt.Errorf("redis: unsupported pubsub message: %#v", reply)
        }
}

// ReceiveTimeout acts like Receive but returns an error if message
// is not received in time. This is low-level API and in most cases
// Channel should be used instead.
func (c *PubSub) ReceiveTimeout(ctx context.Context, timeout time.Duration) (interface{}, error) {
        if c.cmd == nil {
                c.cmd = NewCmd(ctx)
        }

        // Don't hold the lock to allow subscriptions and pings.

        cn, err := c.connWithLock(ctx)
        if err != nil {
                return nil, err
        }

        err = cn.WithReader(ctx, timeout, func(rd *proto.Reader) error {
                return c.cmd.readReply(rd)
        })

        c.releaseConnWithLock(ctx, cn, err, timeout > 0)

        if err != nil {
                return nil, err
        }

        return c.newMessage(c.cmd.Val())
}

// Receive returns a message as a Subscription, Message, Pong or error.
// See PubSub example for details. This is low-level API and in most cases
// Channel should be used instead.
func (c *PubSub) Receive(ctx context.Context) (interface{}, error) {
        return c.ReceiveTimeout(ctx, 0)
}

// ReceiveMessage returns a Message or error ignoring Subscription and Pong
// messages. This is low-level API and in most cases Channel should be used
// instead.
func (c *PubSub) ReceiveMessage(ctx context.Context) (*Message, error) {
        for {
                msg, err := c.Receive(ctx)
                if err != nil {
                        return nil, err
                }

                switch msg := msg.(type) {
                case *Subscription:
                        // Ignore.
                case *Pong:
                        // Ignore.
                case *Message:
                        return msg, nil
                default:
                        err := fmt.Errorf("redis: unknown message: %T", msg)
                        return nil, err
                }
        }
}

func (c *PubSub) getContext() context.Context {
        if c.cmd != nil {
                return c.cmd.ctx
        }
        return context.Background()
}

//------------------------------------------------------------------------------

// Channel returns a Go channel for concurrently receiving messages.
// The channel is closed together with the PubSub. If the Go channel
// is blocked full for 1 minute the message is dropped.
// Receive* APIs can not be used after channel is created.
//
// go-redis periodically sends ping messages to test connection health
// and re-subscribes if ping can not received for 1 minute.
func (c *PubSub) Channel(opts ...ChannelOption) <-chan *Message {
        c.chOnce.Do(func() {
                c.msgCh = newChannel(c, opts...)
                c.msgCh.initMsgChan()
        })
        if c.msgCh == nil {
                err := fmt.Errorf("redis: Channel can't be called after ChannelWithSubscriptions")
                panic(err)
        }
        return c.msgCh.msgCh
}

// ChannelSize is like Channel, but creates a Go channel
// with specified buffer size.
//
// Deprecated: use Channel(WithChannelSize(size)), remove in v9.
func (c *PubSub) ChannelSize(size int) <-chan *Message {
        return c.Channel(WithChannelSize(size))
}

// ChannelWithSubscriptions is like Channel, but message type can be either
// *Subscription or *Message. Subscription messages can be used to detect
// reconnections.
//
// ChannelWithSubscriptions can not be used together with Channel or ChannelSize.
func (c *PubSub) ChannelWithSubscriptions(opts ...ChannelOption) <-chan interface{} {
        c.chOnce.Do(func() {
                c.allCh = newChannel(c, opts...)
                c.allCh.initAllChan()
        })
        if c.allCh == nil {
                err := fmt.Errorf("redis: ChannelWithSubscriptions can't be called after Channel")
                panic(err)
        }
        return c.allCh.allCh
}

type ChannelOption func(c *channel)

// WithChannelSize specifies the Go chan size that is used to buffer incoming messages.
//
// The default is 100 messages.
func WithChannelSize(size int) ChannelOption {
        return func(c *channel) {
                c.chanSize = size
        }
}

// WithChannelHealthCheckInterval specifies the health check interval.
// PubSub will ping Redis Server if it does not receive any messages within the interval.
// To disable health check, use zero interval.
//
// The default is 3 seconds.
func WithChannelHealthCheckInterval(d time.Duration) ChannelOption {
        return func(c *channel) {
                c.checkInterval = d
        }
}

// WithChannelSendTimeout specifies the channel send timeout after which
// the message is dropped.
//
// The default is 60 seconds.
func WithChannelSendTimeout(d time.Duration) ChannelOption {
        return func(c *channel) {
                c.chanSendTimeout = d
        }
}

type channel struct {
        pubSub *PubSub

        msgCh chan *Message
        allCh chan interface{}
        ping  chan struct{}

        chanSize        int
        chanSendTimeout time.Duration
        checkInterval   time.Duration
}

func newChannel(pubSub *PubSub, opts ...ChannelOption) *channel {
        c := &channel{
                pubSub: pubSub,

                chanSize:        100,
                chanSendTimeout: time.Minute,
                checkInterval:   3 * time.Second,
        }
        for _, opt := range opts {
                opt(c)
        }
        if c.checkInterval > 0 {
                c.initHealthCheck()
        }
        return c
}

func (c *channel) initHealthCheck() {
        ctx := context.TODO()
        c.ping = make(chan struct{}, 1)

        go func() {
                timer := time.NewTimer(time.Minute)
                timer.Stop()

                for {
                        timer.Reset(c.checkInterval)
                        select {
                        case <-c.ping:
                                if !timer.Stop() {
                                        <-timer.C
                                }
                        case <-timer.C:
                                if pingErr := c.pubSub.Ping(ctx); pingErr != nil {
                                        c.pubSub.mu.Lock()
                                        c.pubSub.reconnect(ctx, pingErr)
                                        c.pubSub.mu.Unlock()
                                }
                        case <-c.pubSub.exit:
                                return
                        }
                }
        }()
}

// initMsgChan must be in sync with initAllChan.
func (c *channel) initMsgChan() {
        ctx := context.TODO()
        c.msgCh = make(chan *Message, c.chanSize)

        go func() {
                timer := time.NewTimer(time.Minute)
                timer.Stop()

                var errCount int
                for {
                        msg, err := c.pubSub.Receive(ctx)
                        if err != nil {
                                if err == pool.ErrClosed {
                                        close(c.msgCh)
                                        return
                                }
                                if errCount > 0 {
                                        time.Sleep(100 * time.Millisecond)
                                }
                                errCount++
                                continue
                        }

                        errCount = 0

                        // Any message is as good as a ping.
                        select {
                        case c.ping <- struct{}{}:
                        default:
                        }

                        switch msg := msg.(type) {
                        case *Subscription:
                                // Ignore.
                        case *Pong:
                                // Ignore.
                        case *Message:
                                timer.Reset(c.chanSendTimeout)
                                select {
                                case c.msgCh <- msg:
                                        if !timer.Stop() {
                                                <-timer.C
                                        }
                                case <-timer.C:
                                        internal.Logger.Printf(
                                                ctx, "redis: %s channel is full for %s (message is dropped)",
                                                c, c.chanSendTimeout)
                                }
                        default:
                                internal.Logger.Printf(ctx, "redis: unknown message type: %T", msg)
                        }
                }
        }()
}

// initAllChan must be in sync with initMsgChan.
func (c *channel) initAllChan() {
        ctx := context.TODO()
        c.allCh = make(chan interface{}, c.chanSize)

        go func() {
                timer := time.NewTimer(time.Minute)
                timer.Stop()

                var errCount int
                for {
                        msg, err := c.pubSub.Receive(ctx)
                        if err != nil {
                                if err == pool.ErrClosed {
                                        close(c.allCh)
                                        return
                                }
                                if errCount > 0 {
                                        time.Sleep(100 * time.Millisecond)
                                }
                                errCount++
                                continue
                        }

                        errCount = 0

                        // Any message is as good as a ping.
                        select {
                        case c.ping <- struct{}{}:
                        default:
                        }

                        switch msg := msg.(type) {
                        case *Pong:
                                // Ignore.
                        case *Subscription, *Message:
                                timer.Reset(c.chanSendTimeout)
                                select {
                                case c.allCh <- msg:
                                        if !timer.Stop() {
                                                <-timer.C
                                        }
                                case <-timer.C:
                                        internal.Logger.Printf(
                                                ctx, "redis: %s channel is full for %s (message is dropped)",
                                                c, c.chanSendTimeout)
                                }
                        default:
                                internal.Logger.Printf(ctx, "redis: unknown message type: %T", msg)
                        }
                }
        }()
}

package redis

import "context"

type PubSubCmdable interface {
        Publish(ctx context.Context, channel string, message interface{}) *IntCmd
        SPublish(ctx context.Context, channel string, message interface{}) *IntCmd
        PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd
        PubSubNumSub(ctx context.Context, channels ...string) *MapStringIntCmd
        PubSubNumPat(ctx context.Context) *IntCmd
        PubSubShardChannels(ctx context.Context, pattern string) *StringSliceCmd
        PubSubShardNumSub(ctx context.Context, channels ...string) *MapStringIntCmd
}

// Publish posts the message to the channel.
func (c cmdable) Publish(ctx context.Context, channel string, message interface{}) *IntCmd {
        cmd := NewIntCmd(ctx, "publish", channel, message)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SPublish(ctx context.Context, channel string, message interface{}) *IntCmd {
        cmd := NewIntCmd(ctx, "spublish", channel, message)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd {
        args := []interface{}{"pubsub", "channels"}
        if pattern != "*" {
                args = append(args, pattern)
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PubSubNumSub(ctx context.Context, channels ...string) *MapStringIntCmd {
        args := make([]interface{}, 2+len(channels))
        args[0] = "pubsub"
        args[1] = "numsub"
        for i, channel := range channels {
                args[2+i] = channel
        }
        cmd := NewMapStringIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PubSubShardChannels(ctx context.Context, pattern string) *StringSliceCmd {
        args := []interface{}{"pubsub", "shardchannels"}
        if pattern != "*" {
                args = append(args, pattern)
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PubSubShardNumSub(ctx context.Context, channels ...string) *MapStringIntCmd {
        args := make([]interface{}, 2+len(channels))
        args[0] = "pubsub"
        args[1] = "shardnumsub"
        for i, channel := range channels {
                args[2+i] = channel
        }
        cmd := NewMapStringIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) PubSubNumPat(ctx context.Context) *IntCmd {
        cmd := NewIntCmd(ctx, "pubsub", "numpat")
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "errors"
        "fmt"
        "net"
        "sync"
        "sync/atomic"
        "time"

        "github.com/redis/go-redis/v9/auth"
        "github.com/redis/go-redis/v9/internal"
        "github.com/redis/go-redis/v9/internal/hscan"
        "github.com/redis/go-redis/v9/internal/pool"
        "github.com/redis/go-redis/v9/internal/proto"
)

// Scanner internal/hscan.Scanner exposed interface.
type Scanner = hscan.Scanner

// Nil reply returned by Redis when key does not exist.
const Nil = proto.Nil

// SetLogger set custom log
func SetLogger(logger internal.Logging) {
        internal.Logger = logger
}

//------------------------------------------------------------------------------

type Hook interface {
        DialHook(next DialHook) DialHook
        ProcessHook(next ProcessHook) ProcessHook
        ProcessPipelineHook(next ProcessPipelineHook) ProcessPipelineHook
}

type (
        DialHook            func(ctx context.Context, network, addr string) (net.Conn, error)
        ProcessHook         func(ctx context.Context, cmd Cmder) error
        ProcessPipelineHook func(ctx context.Context, cmds []Cmder) error
)

type hooksMixin struct {
        hooksMu *sync.RWMutex

        slice   []Hook
        initial hooks
        current hooks
}

func (hs *hooksMixin) initHooks(hooks hooks) {
        hs.hooksMu = new(sync.RWMutex)
        hs.initial = hooks
        hs.chain()
}

type hooks struct {
        dial       DialHook
        process    ProcessHook
        pipeline   ProcessPipelineHook
        txPipeline ProcessPipelineHook
}

func (h *hooks) setDefaults() {
        if h.dial == nil {
                h.dial = func(ctx context.Context, network, addr string) (net.Conn, error) { return nil, nil }
        }
        if h.process == nil {
                h.process = func(ctx context.Context, cmd Cmder) error { return nil }
        }
        if h.pipeline == nil {
                h.pipeline = func(ctx context.Context, cmds []Cmder) error { return nil }
        }
        if h.txPipeline == nil {
                h.txPipeline = func(ctx context.Context, cmds []Cmder) error { return nil }
        }
}

// AddHook is to add a hook to the queue.
// Hook is a function executed during network connection, command execution, and pipeline,
// it is a first-in-first-out stack queue (FIFO).
// You need to execute the next hook in each hook, unless you want to terminate the execution of the command.
// For example, you added hook-1, hook-2:
//
//        client.AddHook(hook-1, hook-2)
//
// hook-1:
//
//        func (Hook1) ProcessHook(next redis.ProcessHook) redis.ProcessHook {
//                 return func(ctx context.Context, cmd Cmder) error {
//                         print("hook-1 start")
//                         next(ctx, cmd)
//                         print("hook-1 end")
//                         return nil
//                 }
//        }
//
// hook-2:
//
//        func (Hook2) ProcessHook(next redis.ProcessHook) redis.ProcessHook {
//                return func(ctx context.Context, cmd redis.Cmder) error {
//                        print("hook-2 start")
//                        next(ctx, cmd)
//                        print("hook-2 end")
//                        return nil
//                }
//        }
//
// The execution sequence is:
//
//        hook-1 start -> hook-2 start -> exec redis cmd -> hook-2 end -> hook-1 end
//
// Please note: "next(ctx, cmd)" is very important, it will call the next hook,
// if "next(ctx, cmd)" is not executed, the redis command will not be executed.
func (hs *hooksMixin) AddHook(hook Hook) {
        hs.slice = append(hs.slice, hook)
        hs.chain()
}

func (hs *hooksMixin) chain() {
        hs.initial.setDefaults()

        hs.hooksMu.Lock()
        defer hs.hooksMu.Unlock()

        hs.current.dial = hs.initial.dial
        hs.current.process = hs.initial.process
        hs.current.pipeline = hs.initial.pipeline
        hs.current.txPipeline = hs.initial.txPipeline

        for i := len(hs.slice) - 1; i >= 0; i-- {
                if wrapped := hs.slice[i].DialHook(hs.current.dial); wrapped != nil {
                        hs.current.dial = wrapped
                }
                if wrapped := hs.slice[i].ProcessHook(hs.current.process); wrapped != nil {
                        hs.current.process = wrapped
                }
                if wrapped := hs.slice[i].ProcessPipelineHook(hs.current.pipeline); wrapped != nil {
                        hs.current.pipeline = wrapped
                }
                if wrapped := hs.slice[i].ProcessPipelineHook(hs.current.txPipeline); wrapped != nil {
                        hs.current.txPipeline = wrapped
                }
        }
}

func (hs *hooksMixin) clone() hooksMixin {
        hs.hooksMu.Lock()
        defer hs.hooksMu.Unlock()

        clone := *hs
        l := len(clone.slice)
        clone.slice = clone.slice[:l:l]
        clone.hooksMu = new(sync.RWMutex)
        return clone
}

func (hs *hooksMixin) withProcessHook(ctx context.Context, cmd Cmder, hook ProcessHook) error {
        for i := len(hs.slice) - 1; i >= 0; i-- {
                if wrapped := hs.slice[i].ProcessHook(hook); wrapped != nil {
                        hook = wrapped
                }
        }
        return hook(ctx, cmd)
}

func (hs *hooksMixin) withProcessPipelineHook(
        ctx context.Context, cmds []Cmder, hook ProcessPipelineHook,
) error {
        for i := len(hs.slice) - 1; i >= 0; i-- {
                if wrapped := hs.slice[i].ProcessPipelineHook(hook); wrapped != nil {
                        hook = wrapped
                }
        }
        return hook(ctx, cmds)
}

func (hs *hooksMixin) dialHook(ctx context.Context, network, addr string) (net.Conn, error) {
        // Access to hs.current is guarded by a read-only lock since it may be mutated by AddHook(...)
        // while this dialer is concurrently accessed by the background connection pool population
        // routine when MinIdleConns > 0.
        hs.hooksMu.RLock()
        current := hs.current
        hs.hooksMu.RUnlock()

        return current.dial(ctx, network, addr)
}

func (hs *hooksMixin) processHook(ctx context.Context, cmd Cmder) error {
        return hs.current.process(ctx, cmd)
}

func (hs *hooksMixin) processPipelineHook(ctx context.Context, cmds []Cmder) error {
        return hs.current.pipeline(ctx, cmds)
}

func (hs *hooksMixin) processTxPipelineHook(ctx context.Context, cmds []Cmder) error {
        return hs.current.txPipeline(ctx, cmds)
}

//------------------------------------------------------------------------------

type baseClient struct {
        opt      *Options
        connPool pool.Pooler
        hooksMixin

        onClose func() error // hook called when client is closed
}

func (c *baseClient) clone() *baseClient {
        clone := *c
        return &clone
}

func (c *baseClient) withTimeout(timeout time.Duration) *baseClient {
        opt := c.opt.clone()
        opt.ReadTimeout = timeout
        opt.WriteTimeout = timeout

        clone := c.clone()
        clone.opt = opt

        return clone
}

func (c *baseClient) String() string {
        return fmt.Sprintf("Redis<%s db:%d>", c.getAddr(), c.opt.DB)
}

func (c *baseClient) newConn(ctx context.Context) (*pool.Conn, error) {
        cn, err := c.connPool.NewConn(ctx)
        if err != nil {
                return nil, err
        }

        err = c.initConn(ctx, cn)
        if err != nil {
                _ = c.connPool.CloseConn(cn)
                return nil, err
        }

        return cn, nil
}

func (c *baseClient) getConn(ctx context.Context) (*pool.Conn, error) {
        if c.opt.Limiter != nil {
                err := c.opt.Limiter.Allow()
                if err != nil {
                        return nil, err
                }
        }

        cn, err := c._getConn(ctx)
        if err != nil {
                if c.opt.Limiter != nil {
                        c.opt.Limiter.ReportResult(err)
                }
                return nil, err
        }

        return cn, nil
}

func (c *baseClient) _getConn(ctx context.Context) (*pool.Conn, error) {
        cn, err := c.connPool.Get(ctx)
        if err != nil {
                return nil, err
        }

        if cn.Inited {
                return cn, nil
        }

        if err := c.initConn(ctx, cn); err != nil {
                c.connPool.Remove(ctx, cn, err)
                if err := errors.Unwrap(err); err != nil {
                        return nil, err
                }
                return nil, err
        }

        return cn, nil
}

func (c *baseClient) newReAuthCredentialsListener(poolCn *pool.Conn) auth.CredentialsListener {
        return auth.NewReAuthCredentialsListener(
                c.reAuthConnection(poolCn),
                c.onAuthenticationErr(poolCn),
        )
}

func (c *baseClient) reAuthConnection(poolCn *pool.Conn) func(credentials auth.Credentials) error {
        return func(credentials auth.Credentials) error {
                var err error
                username, password := credentials.BasicAuth()
                ctx := context.Background()
                connPool := pool.NewSingleConnPool(c.connPool, poolCn)
                // hooksMixin are intentionally empty here
                cn := newConn(c.opt, connPool, nil)

                if username != "" {
                        err = cn.AuthACL(ctx, username, password).Err()
                } else {
                        err = cn.Auth(ctx, password).Err()
                }
                return err
        }
}
func (c *baseClient) onAuthenticationErr(poolCn *pool.Conn) func(err error) {
        return func(err error) {
                if err != nil {
                        if isBadConn(err, false, c.opt.Addr) {
                                // Close the connection to force a reconnection.
                                err := c.connPool.CloseConn(poolCn)
                                if err != nil {
                                        internal.Logger.Printf(context.Background(), "redis: failed to close connection: %v", err)
                                        // try to close the network connection directly
                                        // so that no resource is leaked
                                        err := poolCn.Close()
                                        if err != nil {
                                                internal.Logger.Printf(context.Background(), "redis: failed to close network connection: %v", err)
                                        }
                                }
                        }
                        internal.Logger.Printf(context.Background(), "redis: re-authentication failed: %v", err)
                }
        }
}

func (c *baseClient) wrappedOnClose(newOnClose func() error) func() error {
        onClose := c.onClose
        return func() error {
                var firstErr error
                err := newOnClose()
                // Even if we have an error we would like to execute the onClose hook
                // if it exists. We will return the first error that occurred.
                // This is to keep error handling consistent with the rest of the code.
                if err != nil {
                        firstErr = err
                }
                if onClose != nil {
                        err = onClose()
                        if err != nil && firstErr == nil {
                                firstErr = err
                        }
                }
                return firstErr
        }
}

func (c *baseClient) initConn(ctx context.Context, cn *pool.Conn) error {
        if cn.Inited {
                return nil
        }

        var err error
        cn.Inited = true
        connPool := pool.NewSingleConnPool(c.connPool, cn)
        conn := newConn(c.opt, connPool, &c.hooksMixin)

        username, password := "", ""
        if c.opt.StreamingCredentialsProvider != nil {
                credentials, unsubscribeFromCredentialsProvider, err := c.opt.StreamingCredentialsProvider.
                        Subscribe(c.newReAuthCredentialsListener(cn))
                if err != nil {
                        return fmt.Errorf("failed to subscribe to streaming credentials: %w", err)
                }
                c.onClose = c.wrappedOnClose(unsubscribeFromCredentialsProvider)
                cn.SetOnClose(unsubscribeFromCredentialsProvider)
                username, password = credentials.BasicAuth()
        } else if c.opt.CredentialsProviderContext != nil {
                username, password, err = c.opt.CredentialsProviderContext(ctx)
                if err != nil {
                        return fmt.Errorf("failed to get credentials from context provider: %w", err)
                }
        } else if c.opt.CredentialsProvider != nil {
                username, password = c.opt.CredentialsProvider()
        } else if c.opt.Username != "" || c.opt.Password != "" {
                username, password = c.opt.Username, c.opt.Password
        }

        // for redis-server versions that do not support the HELLO command,
        // RESP2 will continue to be used.
  if err = conn.Hello(ctx, c.opt.Protocol, username, password, c.opt.ClientName).Err(); err == nil {
                // Authentication successful with HELLO command
        } else if !isRedisError(err) {
                // When the server responds with the RESP protocol and the result is not a normal
                // execution result of the HELLO command, we consider it to be an indication that
                // the server does not support the HELLO command.
                // The server may be a redis-server that does not support the HELLO command,
                // or it could be DragonflyDB or a third-party redis-proxy. They all respond
                // with different error string results for unsupported commands, making it
                // difficult to rely on error strings to determine all results.
                return err
        } else if password != "" {
                // Try legacy AUTH command if HELLO failed
                if username != "" {
                        err = conn.AuthACL(ctx, username, password).Err()
                } else {
                        err = conn.Auth(ctx, password).Err()
                }
                if err != nil {
                        return fmt.Errorf("failed to authenticate: %w", err)
                }
        }

        _, err = conn.Pipelined(ctx, func(pipe Pipeliner) error {
                if c.opt.DB > 0 {
                        pipe.Select(ctx, c.opt.DB)
                }

                if c.opt.readOnly {
                        pipe.ReadOnly(ctx)
                }

                if c.opt.ClientName != "" {
                        pipe.ClientSetName(ctx, c.opt.ClientName)
                }

                return nil
        })
        if err != nil {
                return fmt.Errorf("failed to initialize connection options: %w", err)
        }

        if !c.opt.DisableIdentity && !c.opt.DisableIndentity {
                libName := ""
                libVer := Version()
                if c.opt.IdentitySuffix != "" {
                        libName = c.opt.IdentitySuffix
                }
                p := conn.Pipeline()
                p.ClientSetInfo(ctx, WithLibraryName(libName))
                p.ClientSetInfo(ctx, WithLibraryVersion(libVer))
                // Handle network errors (e.g. timeouts) in CLIENT SETINFO to avoid
                // out of order responses later on.
                if _, err = p.Exec(ctx); err != nil && !isRedisError(err) {
                        return err
                }
        }

        if c.opt.OnConnect != nil {
                return c.opt.OnConnect(ctx, conn)
        }

        return nil
}

func (c *baseClient) releaseConn(ctx context.Context, cn *pool.Conn, err error) {
        if c.opt.Limiter != nil {
                c.opt.Limiter.ReportResult(err)
        }

        if isBadConn(err, false, c.opt.Addr) {
                c.connPool.Remove(ctx, cn, err)
        } else {
                c.connPool.Put(ctx, cn)
        }
}

func (c *baseClient) withConn(
        ctx context.Context, fn func(context.Context, *pool.Conn) error,
) error {
        cn, err := c.getConn(ctx)
        if err != nil {
                return err
        }

        var fnErr error
        defer func() {
                c.releaseConn(ctx, cn, fnErr)
        }()

        fnErr = fn(ctx, cn)

        return fnErr
}

func (c *baseClient) dial(ctx context.Context, network, addr string) (net.Conn, error) {
        return c.opt.Dialer(ctx, network, addr)
}

func (c *baseClient) process(ctx context.Context, cmd Cmder) error {
        var lastErr error
        for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
                attempt := attempt

                retry, err := c._process(ctx, cmd, attempt)
                if err == nil || !retry {
                        return err
                }

                lastErr = err
        }
        return lastErr
}

func (c *baseClient) assertUnstableCommand(cmd Cmder) bool {
        switch cmd.(type) {
        case *AggregateCmd, *FTInfoCmd, *FTSpellCheckCmd, *FTSearchCmd, *FTSynDumpCmd:
                if c.opt.UnstableResp3 {
                        return true
                } else {
                        panic("RESP3 responses for this command are disabled because they may still change. Please set the flag UnstableResp3 .  See the [README](https://github.com/redis/go-redis/blob/master/README.md) and the release notes for guidance.")
                }
        default:
                return false
        }
}

func (c *baseClient) _process(ctx context.Context, cmd Cmder, attempt int) (bool, error) {
        if attempt > 0 {
                if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
                        return false, err
                }
        }

        retryTimeout := uint32(0)
        if err := c.withConn(ctx, func(ctx context.Context, cn *pool.Conn) error {
                if err := cn.WithWriter(c.context(ctx), c.opt.WriteTimeout, func(wr *proto.Writer) error {
                        return writeCmd(wr, cmd)
                }); err != nil {
                        atomic.StoreUint32(&retryTimeout, 1)
                        return err
                }
                readReplyFunc := cmd.readReply
                // Apply unstable RESP3 search module.
                if c.opt.Protocol != 2 && c.assertUnstableCommand(cmd) {
                        readReplyFunc = cmd.readRawReply
                }
                if err := cn.WithReader(c.context(ctx), c.cmdTimeout(cmd), readReplyFunc); err != nil {
                        if cmd.readTimeout() == nil {
                                atomic.StoreUint32(&retryTimeout, 1)
                        } else {
                                atomic.StoreUint32(&retryTimeout, 0)
                        }
                        return err
                }

                return nil
        }); err != nil {
                retry := shouldRetry(err, atomic.LoadUint32(&retryTimeout) == 1)
                return retry, err
        }

        return false, nil
}

func (c *baseClient) retryBackoff(attempt int) time.Duration {
        return internal.RetryBackoff(attempt, c.opt.MinRetryBackoff, c.opt.MaxRetryBackoff)
}

func (c *baseClient) cmdTimeout(cmd Cmder) time.Duration {
        if timeout := cmd.readTimeout(); timeout != nil {
                t := *timeout
                if t == 0 {
                        return 0
                }
                return t + 10*time.Second
        }
        return c.opt.ReadTimeout
}

// context returns the context for the current connection.
// If the context timeout is enabled, it returns the original context.
// Otherwise, it returns a new background context.
func (c *baseClient) context(ctx context.Context) context.Context {
        if c.opt.ContextTimeoutEnabled {
                return ctx
        }
        return context.Background()
}

// Close closes the client, releasing any open resources.
//
// It is rare to Close a Client, as the Client is meant to be
// long-lived and shared between many goroutines.
func (c *baseClient) Close() error {
        var firstErr error
        if c.onClose != nil {
                if err := c.onClose(); err != nil {
                        firstErr = err
                }
        }
        if err := c.connPool.Close(); err != nil && firstErr == nil {
                firstErr = err
        }
        return firstErr
}

func (c *baseClient) getAddr() string {
        return c.opt.Addr
}

func (c *baseClient) processPipeline(ctx context.Context, cmds []Cmder) error {
        if err := c.generalProcessPipeline(ctx, cmds, c.pipelineProcessCmds); err != nil {
                return err
        }
        return cmdsFirstErr(cmds)
}

func (c *baseClient) processTxPipeline(ctx context.Context, cmds []Cmder) error {
        if err := c.generalProcessPipeline(ctx, cmds, c.txPipelineProcessCmds); err != nil {
                return err
        }
        return cmdsFirstErr(cmds)
}

type pipelineProcessor func(context.Context, *pool.Conn, []Cmder) (bool, error)

func (c *baseClient) generalProcessPipeline(
        ctx context.Context, cmds []Cmder, p pipelineProcessor,
) error {
        var lastErr error
        for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
                if attempt > 0 {
                        if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
                                setCmdsErr(cmds, err)
                                return err
                        }
                }

                // Enable retries by default to retry dial errors returned by withConn.
                canRetry := true
                lastErr = c.withConn(ctx, func(ctx context.Context, cn *pool.Conn) error {
                        var err error
                        canRetry, err = p(ctx, cn, cmds)
                        return err
                })
                if lastErr == nil || !canRetry || !shouldRetry(lastErr, true) {
                        return lastErr
                }
        }
        return lastErr
}

func (c *baseClient) pipelineProcessCmds(
        ctx context.Context, cn *pool.Conn, cmds []Cmder,
) (bool, error) {
        if err := cn.WithWriter(c.context(ctx), c.opt.WriteTimeout, func(wr *proto.Writer) error {
                return writeCmds(wr, cmds)
        }); err != nil {
                setCmdsErr(cmds, err)
                return true, err
        }

        if err := cn.WithReader(c.context(ctx), c.opt.ReadTimeout, func(rd *proto.Reader) error {
                return pipelineReadCmds(rd, cmds)
        }); err != nil {
                return true, err
        }

        return false, nil
}

func pipelineReadCmds(rd *proto.Reader, cmds []Cmder) error {
        for i, cmd := range cmds {
                err := cmd.readReply(rd)
                cmd.SetErr(err)
                if err != nil && !isRedisError(err) {
                        setCmdsErr(cmds[i+1:], err)
                        return err
                }
        }
        // Retry errors like "LOADING redis is loading the dataset in memory".
        return cmds[0].Err()
}

func (c *baseClient) txPipelineProcessCmds(
        ctx context.Context, cn *pool.Conn, cmds []Cmder,
) (bool, error) {
        if err := cn.WithWriter(c.context(ctx), c.opt.WriteTimeout, func(wr *proto.Writer) error {
                return writeCmds(wr, cmds)
        }); err != nil {
                setCmdsErr(cmds, err)
                return true, err
        }

        if err := cn.WithReader(c.context(ctx), c.opt.ReadTimeout, func(rd *proto.Reader) error {
                statusCmd := cmds[0].(*StatusCmd)
                // Trim multi and exec.
                trimmedCmds := cmds[1 : len(cmds)-1]

                if err := txPipelineReadQueued(rd, statusCmd, trimmedCmds); err != nil {
                        setCmdsErr(cmds, err)
                        return err
                }

                return pipelineReadCmds(rd, trimmedCmds)
        }); err != nil {
                return false, err
        }

        return false, nil
}

func txPipelineReadQueued(rd *proto.Reader, statusCmd *StatusCmd, cmds []Cmder) error {
        // Parse +OK.
        if err := statusCmd.readReply(rd); err != nil {
                return err
        }

        // Parse +QUEUED.
        for range cmds {
                if err := statusCmd.readReply(rd); err != nil && !isRedisError(err) {
                        return err
                }
        }

        // Parse number of replies.
        line, err := rd.ReadLine()
        if err != nil {
                if err == Nil {
                        err = TxFailedErr
                }
                return err
        }

        if line[0] != proto.RespArray {
                return fmt.Errorf("redis: expected '*', but got line %q", line)
        }

        return nil
}

//------------------------------------------------------------------------------

// Client is a Redis client representing a pool of zero or more underlying connections.
// It's safe for concurrent use by multiple goroutines.
//
// Client creates and frees connections automatically; it also maintains a free pool
// of idle connections. You can control the pool size with Config.PoolSize option.
type Client struct {
        *baseClient
        cmdable
}

// NewClient returns a client to the Redis Server specified by Options.
func NewClient(opt *Options) *Client {
        if opt == nil {
                panic("redis: NewClient nil options")
        }
        opt.init()

        c := Client{
                baseClient: &baseClient{
                        opt: opt,
                },
        }
        c.init()
        c.connPool = newConnPool(opt, c.dialHook)

        return &c
}

func (c *Client) init() {
        c.cmdable = c.Process
        c.initHooks(hooks{
                dial:       c.baseClient.dial,
                process:    c.baseClient.process,
                pipeline:   c.baseClient.processPipeline,
                txPipeline: c.baseClient.processTxPipeline,
        })
}

func (c *Client) WithTimeout(timeout time.Duration) *Client {
        clone := *c
        clone.baseClient = c.baseClient.withTimeout(timeout)
        clone.init()
        return &clone
}

func (c *Client) Conn() *Conn {
        return newConn(c.opt, pool.NewStickyConnPool(c.connPool), &c.hooksMixin)
}

func (c *Client) Process(ctx context.Context, cmd Cmder) error {
        err := c.processHook(ctx, cmd)
        cmd.SetErr(err)
        return err
}

// Options returns read-only Options that were used to create the client.
func (c *Client) Options() *Options {
        return c.opt
}

type PoolStats pool.Stats

// PoolStats returns connection pool stats.
func (c *Client) PoolStats() *PoolStats {
        stats := c.connPool.Stats()
        return (*PoolStats)(stats)
}

func (c *Client) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.Pipeline().Pipelined(ctx, fn)
}

func (c *Client) Pipeline() Pipeliner {
        pipe := Pipeline{
                exec: pipelineExecer(c.processPipelineHook),
        }
        pipe.init()
        return &pipe
}

func (c *Client) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.TxPipeline().Pipelined(ctx, fn)
}

// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
func (c *Client) TxPipeline() Pipeliner {
        pipe := Pipeline{
                exec: func(ctx context.Context, cmds []Cmder) error {
                        cmds = wrapMultiExec(ctx, cmds)
                        return c.processTxPipelineHook(ctx, cmds)
                },
        }
        pipe.init()
        return &pipe
}

func (c *Client) pubSub() *PubSub {
        pubsub := &PubSub{
                opt: c.opt,

                newConn: func(ctx context.Context, channels []string) (*pool.Conn, error) {
                        return c.newConn(ctx)
                },
                closeConn: c.connPool.CloseConn,
        }
        pubsub.init()
        return pubsub
}

// Subscribe subscribes the client to the specified channels.
// Channels can be omitted to create empty subscription.
// Note that this method does not wait on a response from Redis, so the
// subscription may not be active immediately. To force the connection to wait,
// you may call the Receive() method on the returned *PubSub like so:
//
//        sub := client.Subscribe(queryResp)
//        iface, err := sub.Receive()
//        if err != nil {
//            // handle error
//        }
//
//        // Should be *Subscription, but others are possible if other actions have been
//        // taken on sub since it was created.
//        switch iface.(type) {
//        case *Subscription:
//            // subscribe succeeded
//        case *Message:
//            // received first message
//        case *Pong:
//            // pong received
//        default:
//            // handle error
//        }
//
//        ch := sub.Channel()
func (c *Client) Subscribe(ctx context.Context, channels ...string) *PubSub {
        pubsub := c.pubSub()
        if len(channels) > 0 {
                _ = pubsub.Subscribe(ctx, channels...)
        }
        return pubsub
}

// PSubscribe subscribes the client to the given patterns.
// Patterns can be omitted to create empty subscription.
func (c *Client) PSubscribe(ctx context.Context, channels ...string) *PubSub {
        pubsub := c.pubSub()
        if len(channels) > 0 {
                _ = pubsub.PSubscribe(ctx, channels...)
        }
        return pubsub
}

// SSubscribe Subscribes the client to the specified shard channels.
// Channels can be omitted to create empty subscription.
func (c *Client) SSubscribe(ctx context.Context, channels ...string) *PubSub {
        pubsub := c.pubSub()
        if len(channels) > 0 {
                _ = pubsub.SSubscribe(ctx, channels...)
        }
        return pubsub
}

//------------------------------------------------------------------------------

// Conn represents a single Redis connection rather than a pool of connections.
// Prefer running commands from Client unless there is a specific need
// for a continuous single Redis connection.
type Conn struct {
        baseClient
        cmdable
        statefulCmdable
}

// newConn is a helper func to create a new Conn instance.
// the Conn instance is not thread-safe and should not be shared between goroutines.
// the parentHooks will be cloned, no need to clone before passing it.
func newConn(opt *Options, connPool pool.Pooler, parentHooks *hooksMixin) *Conn {
        c := Conn{
                baseClient: baseClient{
                        opt:      opt,
                        connPool: connPool,
                },
        }

        if parentHooks != nil {
                c.hooksMixin = parentHooks.clone()
        }

        c.cmdable = c.Process
        c.statefulCmdable = c.Process
        c.initHooks(hooks{
                dial:       c.baseClient.dial,
                process:    c.baseClient.process,
                pipeline:   c.baseClient.processPipeline,
                txPipeline: c.baseClient.processTxPipeline,
        })

        return &c
}

func (c *Conn) Process(ctx context.Context, cmd Cmder) error {
        err := c.processHook(ctx, cmd)
        cmd.SetErr(err)
        return err
}

func (c *Conn) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.Pipeline().Pipelined(ctx, fn)
}

func (c *Conn) Pipeline() Pipeliner {
        pipe := Pipeline{
                exec: c.processPipelineHook,
        }
        pipe.init()
        return &pipe
}

func (c *Conn) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.TxPipeline().Pipelined(ctx, fn)
}

// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
func (c *Conn) TxPipeline() Pipeliner {
        pipe := Pipeline{
                exec: func(ctx context.Context, cmds []Cmder) error {
                        cmds = wrapMultiExec(ctx, cmds)
                        return c.processTxPipelineHook(ctx, cmds)
                },
        }
        pipe.init()
        return &pipe
}

package redis

import "time"

// NewCmdResult returns a Cmd initialised with val and err for testing.
func NewCmdResult(val interface{}, err error) *Cmd {
        var cmd Cmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewSliceResult returns a SliceCmd initialised with val and err for testing.
func NewSliceResult(val []interface{}, err error) *SliceCmd {
        var cmd SliceCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewStatusResult returns a StatusCmd initialised with val and err for testing.
func NewStatusResult(val string, err error) *StatusCmd {
        var cmd StatusCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewIntResult returns an IntCmd initialised with val and err for testing.
func NewIntResult(val int64, err error) *IntCmd {
        var cmd IntCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewDurationResult returns a DurationCmd initialised with val and err for testing.
func NewDurationResult(val time.Duration, err error) *DurationCmd {
        var cmd DurationCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewBoolResult returns a BoolCmd initialised with val and err for testing.
func NewBoolResult(val bool, err error) *BoolCmd {
        var cmd BoolCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewStringResult returns a StringCmd initialised with val and err for testing.
func NewStringResult(val string, err error) *StringCmd {
        var cmd StringCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewFloatResult returns a FloatCmd initialised with val and err for testing.
func NewFloatResult(val float64, err error) *FloatCmd {
        var cmd FloatCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewStringSliceResult returns a StringSliceCmd initialised with val and err for testing.
func NewStringSliceResult(val []string, err error) *StringSliceCmd {
        var cmd StringSliceCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewBoolSliceResult returns a BoolSliceCmd initialised with val and err for testing.
func NewBoolSliceResult(val []bool, err error) *BoolSliceCmd {
        var cmd BoolSliceCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewFloatSliceResult returns a FloatSliceCmd initialised with val and err for testing.
func NewFloatSliceResult(val []float64, err error) *FloatSliceCmd {
        var cmd FloatSliceCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewMapStringStringResult returns a MapStringStringCmd initialised with val and err for testing.
func NewMapStringStringResult(val map[string]string, err error) *MapStringStringCmd {
        var cmd MapStringStringCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewMapStringIntCmdResult returns a MapStringIntCmd initialised with val and err for testing.
func NewMapStringIntCmdResult(val map[string]int64, err error) *MapStringIntCmd {
        var cmd MapStringIntCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewTimeCmdResult returns a TimeCmd initialised with val and err for testing.
func NewTimeCmdResult(val time.Time, err error) *TimeCmd {
        var cmd TimeCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewZSliceCmdResult returns a ZSliceCmd initialised with val and err for testing.
func NewZSliceCmdResult(val []Z, err error) *ZSliceCmd {
        var cmd ZSliceCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewZWithKeyCmdResult returns a ZWithKeyCmd initialised with val and err for testing.
func NewZWithKeyCmdResult(val *ZWithKey, err error) *ZWithKeyCmd {
        var cmd ZWithKeyCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewScanCmdResult returns a ScanCmd initialised with val and err for testing.
func NewScanCmdResult(keys []string, cursor uint64, err error) *ScanCmd {
        var cmd ScanCmd
        cmd.page = keys
        cmd.cursor = cursor
        cmd.SetErr(err)
        return &cmd
}

// NewClusterSlotsCmdResult returns a ClusterSlotsCmd initialised with val and err for testing.
func NewClusterSlotsCmdResult(val []ClusterSlot, err error) *ClusterSlotsCmd {
        var cmd ClusterSlotsCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewGeoLocationCmdResult returns a GeoLocationCmd initialised with val and err for testing.
func NewGeoLocationCmdResult(val []GeoLocation, err error) *GeoLocationCmd {
        var cmd GeoLocationCmd
        cmd.locations = val
        cmd.SetErr(err)
        return &cmd
}

// NewGeoPosCmdResult returns a GeoPosCmd initialised with val and err for testing.
func NewGeoPosCmdResult(val []*GeoPos, err error) *GeoPosCmd {
        var cmd GeoPosCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewCommandsInfoCmdResult returns a CommandsInfoCmd initialised with val and err for testing.
func NewCommandsInfoCmdResult(val map[string]*CommandInfo, err error) *CommandsInfoCmd {
        var cmd CommandsInfoCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewXMessageSliceCmdResult returns a XMessageSliceCmd initialised with val and err for testing.
func NewXMessageSliceCmdResult(val []XMessage, err error) *XMessageSliceCmd {
        var cmd XMessageSliceCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewXStreamSliceCmdResult returns a XStreamSliceCmd initialised with val and err for testing.
func NewXStreamSliceCmdResult(val []XStream, err error) *XStreamSliceCmd {
        var cmd XStreamSliceCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

// NewXPendingResult returns a XPendingCmd initialised with val and err for testing.
func NewXPendingResult(val *XPending, err error) *XPendingCmd {
        var cmd XPendingCmd
        cmd.val = val
        cmd.SetErr(err)
        return &cmd
}

package redis

import (
        "context"
        "crypto/tls"
        "errors"
        "fmt"
        "net"
        "strconv"
        "sync"
        "sync/atomic"
        "time"

        "github.com/cespare/xxhash/v2"
        "github.com/dgryski/go-rendezvous" //nolint
        "github.com/redis/go-redis/v9/auth"

        "github.com/redis/go-redis/v9/internal"
        "github.com/redis/go-redis/v9/internal/hashtag"
        "github.com/redis/go-redis/v9/internal/pool"
        "github.com/redis/go-redis/v9/internal/rand"
)

var errRingShardsDown = errors.New("redis: all ring shards are down")

//------------------------------------------------------------------------------

type ConsistentHash interface {
        Get(string) string
}

type rendezvousWrapper struct {
        *rendezvous.Rendezvous
}

func (w rendezvousWrapper) Get(key string) string {
        return w.Lookup(key)
}

func newRendezvous(shards []string) ConsistentHash {
        return rendezvousWrapper{rendezvous.New(shards, xxhash.Sum64String)}
}

//------------------------------------------------------------------------------

// RingOptions are used to configure a ring client and should be
// passed to NewRing.
type RingOptions struct {
        // Map of name => host:port addresses of ring shards.
        Addrs map[string]string

        // NewClient creates a shard client with provided options.
        NewClient func(opt *Options) *Client

        // ClientName will execute the `CLIENT SETNAME ClientName` command for each conn.
        ClientName string

        // Frequency of PING commands sent to check shards availability.
        // Shard is considered down after 3 subsequent failed checks.
        HeartbeatFrequency time.Duration

        // NewConsistentHash returns a consistent hash that is used
        // to distribute keys across the shards.
        //
        // See https://medium.com/@dgryski/consistent-hashing-algorithmic-tradeoffs-ef6b8e2fcae8
        // for consistent hashing algorithmic tradeoffs.
        NewConsistentHash func(shards []string) ConsistentHash

        // Following options are copied from Options struct.

        Dialer    func(ctx context.Context, network, addr string) (net.Conn, error)
        OnConnect func(ctx context.Context, cn *Conn) error

        Protocol int
        Username string
        Password string
        // CredentialsProvider allows the username and password to be updated
        // before reconnecting. It should return the current username and password.
        CredentialsProvider func() (username string, password string)

        // CredentialsProviderContext is an enhanced parameter of CredentialsProvider,
        // done to maintain API compatibility. In the future,
        // there might be a merge between CredentialsProviderContext and CredentialsProvider.
        // There will be a conflict between them; if CredentialsProviderContext exists, we will ignore CredentialsProvider.
        CredentialsProviderContext func(ctx context.Context) (username string, password string, err error)

        // StreamingCredentialsProvider is used to retrieve the credentials
        // for the connection from an external source. Those credentials may change
        // during the connection lifetime. This is useful for managed identity
        // scenarios where the credentials are retrieved from an external source.
        //
        // Currently, this is a placeholder for the future implementation.
        StreamingCredentialsProvider auth.StreamingCredentialsProvider
        DB                           int

        MaxRetries      int
        MinRetryBackoff time.Duration
        MaxRetryBackoff time.Duration

        DialTimeout           time.Duration
        ReadTimeout           time.Duration
        WriteTimeout          time.Duration
        ContextTimeoutEnabled bool

        // PoolFIFO uses FIFO mode for each node connection pool GET/PUT (default LIFO).
        PoolFIFO bool

        PoolSize        int
        PoolTimeout     time.Duration
        MinIdleConns    int
        MaxIdleConns    int
        MaxActiveConns  int
        ConnMaxIdleTime time.Duration
        ConnMaxLifetime time.Duration

        TLSConfig *tls.Config
        Limiter   Limiter

        // DisableIndentity - Disable set-lib on connect.
        //
        // default: false
        //
        // Deprecated: Use DisableIdentity instead.
        DisableIndentity bool

        // DisableIdentity is used to disable CLIENT SETINFO command on connect.
        //
        // default: false
        DisableIdentity bool
        IdentitySuffix  string
        UnstableResp3   bool
}

func (opt *RingOptions) init() {
        if opt.NewClient == nil {
                opt.NewClient = func(opt *Options) *Client {
                        return NewClient(opt)
                }
        }

        if opt.HeartbeatFrequency == 0 {
                opt.HeartbeatFrequency = 500 * time.Millisecond
        }

        if opt.NewConsistentHash == nil {
                opt.NewConsistentHash = newRendezvous
        }

        switch opt.MaxRetries {
        case -1:
                opt.MaxRetries = 0
        case 0:
                opt.MaxRetries = 3
        }
        switch opt.MinRetryBackoff {
        case -1:
                opt.MinRetryBackoff = 0
        case 0:
                opt.MinRetryBackoff = 8 * time.Millisecond
        }
        switch opt.MaxRetryBackoff {
        case -1:
                opt.MaxRetryBackoff = 0
        case 0:
                opt.MaxRetryBackoff = 512 * time.Millisecond
        }
}

func (opt *RingOptions) clientOptions() *Options {
        return &Options{
                ClientName: opt.ClientName,
                Dialer:     opt.Dialer,
                OnConnect:  opt.OnConnect,

                Protocol:                     opt.Protocol,
                Username:                     opt.Username,
                Password:                     opt.Password,
                CredentialsProvider:          opt.CredentialsProvider,
                CredentialsProviderContext:   opt.CredentialsProviderContext,
                StreamingCredentialsProvider: opt.StreamingCredentialsProvider,
                DB:                           opt.DB,

                MaxRetries: -1,

                DialTimeout:           opt.DialTimeout,
                ReadTimeout:           opt.ReadTimeout,
                WriteTimeout:          opt.WriteTimeout,
                ContextTimeoutEnabled: opt.ContextTimeoutEnabled,

                PoolFIFO:        opt.PoolFIFO,
                PoolSize:        opt.PoolSize,
                PoolTimeout:     opt.PoolTimeout,
                MinIdleConns:    opt.MinIdleConns,
                MaxIdleConns:    opt.MaxIdleConns,
                MaxActiveConns:  opt.MaxActiveConns,
                ConnMaxIdleTime: opt.ConnMaxIdleTime,
                ConnMaxLifetime: opt.ConnMaxLifetime,

                TLSConfig: opt.TLSConfig,
                Limiter:   opt.Limiter,

                DisableIdentity:  opt.DisableIdentity,
                DisableIndentity: opt.DisableIndentity,

                IdentitySuffix: opt.IdentitySuffix,
                UnstableResp3:  opt.UnstableResp3,
        }
}

//------------------------------------------------------------------------------

type ringShard struct {
        Client *Client
        down   int32
        addr   string
}

func newRingShard(opt *RingOptions, addr string) *ringShard {
        clopt := opt.clientOptions()
        clopt.Addr = addr

        return &ringShard{
                Client: opt.NewClient(clopt),
                addr:   addr,
        }
}

func (shard *ringShard) String() string {
        var state string
        if shard.IsUp() {
                state = "up"
        } else {
                state = "down"
        }
        return fmt.Sprintf("%s is %s", shard.Client, state)
}

func (shard *ringShard) IsDown() bool {
        const threshold = 3
        return atomic.LoadInt32(&shard.down) >= threshold
}

func (shard *ringShard) IsUp() bool {
        return !shard.IsDown()
}

// Vote votes to set shard state and returns true if state was changed.
func (shard *ringShard) Vote(up bool) bool {
        if up {
                changed := shard.IsDown()
                atomic.StoreInt32(&shard.down, 0)
                return changed
        }

        if shard.IsDown() {
                return false
        }

        atomic.AddInt32(&shard.down, 1)
        return shard.IsDown()
}

//------------------------------------------------------------------------------

type ringSharding struct {
        opt *RingOptions

        mu        sync.RWMutex
        shards    *ringShards
        closed    bool
        hash      ConsistentHash
        numShard  int
        onNewNode []func(rdb *Client)

        // ensures exclusive access to SetAddrs so there is no need
        // to hold mu for the duration of potentially long shard creation
        setAddrsMu sync.Mutex
}

type ringShards struct {
        m    map[string]*ringShard
        list []*ringShard
}

func newRingSharding(opt *RingOptions) *ringSharding {
        c := &ringSharding{
                opt: opt,
        }
        c.SetAddrs(opt.Addrs)

        return c
}

func (c *ringSharding) OnNewNode(fn func(rdb *Client)) {
        c.mu.Lock()
        c.onNewNode = append(c.onNewNode, fn)
        c.mu.Unlock()
}

// SetAddrs replaces the shards in use, such that you can increase and
// decrease number of shards, that you use. It will reuse shards that
// existed before and close the ones that will not be used anymore.
func (c *ringSharding) SetAddrs(addrs map[string]string) {
        c.setAddrsMu.Lock()
        defer c.setAddrsMu.Unlock()

        cleanup := func(shards map[string]*ringShard) {
                for addr, shard := range shards {
                        if err := shard.Client.Close(); err != nil {
                                internal.Logger.Printf(context.Background(), "shard.Close %s failed: %s", addr, err)
                        }
                }
        }

        c.mu.RLock()
        if c.closed {
                c.mu.RUnlock()
                return
        }
        existing := c.shards
        c.mu.RUnlock()

        shards, created, unused := c.newRingShards(addrs, existing)

        c.mu.Lock()
        if c.closed {
                cleanup(created)
                c.mu.Unlock()
                return
        }
        c.shards = shards
        c.rebalanceLocked()
        c.mu.Unlock()

        cleanup(unused)
}

func (c *ringSharding) newRingShards(
        addrs map[string]string, existing *ringShards,
) (shards *ringShards, created, unused map[string]*ringShard) {
        shards = &ringShards{m: make(map[string]*ringShard, len(addrs))}
        created = make(map[string]*ringShard) // indexed by addr
        unused = make(map[string]*ringShard)  // indexed by addr

        if existing != nil {
                for _, shard := range existing.list {
                        unused[shard.addr] = shard
                }
        }

        for name, addr := range addrs {
                if shard, ok := unused[addr]; ok {
                        shards.m[name] = shard
                        delete(unused, addr)
                } else {
                        shard := newRingShard(c.opt, addr)
                        shards.m[name] = shard
                        created[addr] = shard

                        for _, fn := range c.onNewNode {
                                fn(shard.Client)
                        }
                }
        }

        for _, shard := range shards.m {
                shards.list = append(shards.list, shard)
        }

        return
}

// Warning: External exposure of `c.shards.list` may cause data races.
// So keep internal or implement deep copy if exposed.
func (c *ringSharding) List() []*ringShard {
        c.mu.RLock()
        defer c.mu.RUnlock()

        if c.closed {
                return nil
        }
        return c.shards.list
}

func (c *ringSharding) Hash(key string) string {
        key = hashtag.Key(key)

        var hash string

        c.mu.RLock()
        defer c.mu.RUnlock()

        if c.numShard > 0 {
                hash = c.hash.Get(key)
        }

        return hash
}

func (c *ringSharding) GetByKey(key string) (*ringShard, error) {
        key = hashtag.Key(key)

        c.mu.RLock()
        defer c.mu.RUnlock()

        if c.closed {
                return nil, pool.ErrClosed
        }

        if c.numShard == 0 {
                return nil, errRingShardsDown
        }

        shardName := c.hash.Get(key)
        if shardName == "" {
                return nil, errRingShardsDown
        }
        return c.shards.m[shardName], nil
}

func (c *ringSharding) GetByName(shardName string) (*ringShard, error) {
        if shardName == "" {
                return c.Random()
        }

        c.mu.RLock()
        defer c.mu.RUnlock()

        shard, ok := c.shards.m[shardName]
        if !ok {
                return nil, errors.New("redis: the shard is not in the ring")
        }

        return shard, nil
}

func (c *ringSharding) Random() (*ringShard, error) {
        return c.GetByKey(strconv.Itoa(rand.Int()))
}

// Heartbeat monitors state of each shard in the ring.
func (c *ringSharding) Heartbeat(ctx context.Context, frequency time.Duration) {
        ticker := time.NewTicker(frequency)
        defer ticker.Stop()

        for {
                select {
                case <-ticker.C:
                        var rebalance bool

                        // note: `c.List()` return a shadow copy of `[]*ringShard`.
                        for _, shard := range c.List() {
                                err := shard.Client.Ping(ctx).Err()
                                isUp := err == nil || err == pool.ErrPoolTimeout
                                if shard.Vote(isUp) {
                                        internal.Logger.Printf(ctx, "ring shard state changed: %s", shard)
                                        rebalance = true
                                }
                        }

                        if rebalance {
                                c.mu.Lock()
                                c.rebalanceLocked()
                                c.mu.Unlock()
                        }
                case <-ctx.Done():
                        return
                }
        }
}

// rebalanceLocked removes dead shards from the Ring.
// Requires c.mu locked.
func (c *ringSharding) rebalanceLocked() {
        if c.closed {
                return
        }
        if c.shards == nil {
                return
        }

        liveShards := make([]string, 0, len(c.shards.m))

        for name, shard := range c.shards.m {
                if shard.IsUp() {
                        liveShards = append(liveShards, name)
                }
        }

        c.hash = c.opt.NewConsistentHash(liveShards)
        c.numShard = len(liveShards)
}

func (c *ringSharding) Len() int {
        c.mu.RLock()
        defer c.mu.RUnlock()

        return c.numShard
}

func (c *ringSharding) Close() error {
        c.mu.Lock()
        defer c.mu.Unlock()

        if c.closed {
                return nil
        }
        c.closed = true

        var firstErr error

        for _, shard := range c.shards.list {
                if err := shard.Client.Close(); err != nil && firstErr == nil {
                        firstErr = err
                }
        }

        c.hash = nil
        c.shards = nil
        c.numShard = 0

        return firstErr
}

//------------------------------------------------------------------------------

// Ring is a Redis client that uses consistent hashing to distribute
// keys across multiple Redis servers (shards). It's safe for
// concurrent use by multiple goroutines.
//
// Ring monitors the state of each shard and removes dead shards from
// the ring. When a shard comes online it is added back to the ring. This
// gives you maximum availability and partition tolerance, but no
// consistency between different shards or even clients. Each client
// uses shards that are available to the client and does not do any
// coordination when shard state is changed.
//
// Ring should be used when you need multiple Redis servers for caching
// and can tolerate losing data when one of the servers dies.
// Otherwise you should use Redis Cluster.
type Ring struct {
        cmdable
        hooksMixin

        opt               *RingOptions
        sharding          *ringSharding
        cmdsInfoCache     *cmdsInfoCache
        heartbeatCancelFn context.CancelFunc
}

func NewRing(opt *RingOptions) *Ring {
        if opt == nil {
                panic("redis: NewRing nil options")
        }
        opt.init()

        hbCtx, hbCancel := context.WithCancel(context.Background())

        ring := Ring{
                opt:               opt,
                sharding:          newRingSharding(opt),
                heartbeatCancelFn: hbCancel,
        }

        ring.cmdsInfoCache = newCmdsInfoCache(ring.cmdsInfo)
        ring.cmdable = ring.Process

        ring.initHooks(hooks{
                process: ring.process,
                pipeline: func(ctx context.Context, cmds []Cmder) error {
                        return ring.generalProcessPipeline(ctx, cmds, false)
                },
                txPipeline: func(ctx context.Context, cmds []Cmder) error {
                        return ring.generalProcessPipeline(ctx, cmds, true)
                },
        })

        go ring.sharding.Heartbeat(hbCtx, opt.HeartbeatFrequency)

        return &ring
}

func (c *Ring) SetAddrs(addrs map[string]string) {
        c.sharding.SetAddrs(addrs)
}

func (c *Ring) Process(ctx context.Context, cmd Cmder) error {
        err := c.processHook(ctx, cmd)
        cmd.SetErr(err)
        return err
}

// Options returns read-only Options that were used to create the client.
func (c *Ring) Options() *RingOptions {
        return c.opt
}

func (c *Ring) retryBackoff(attempt int) time.Duration {
        return internal.RetryBackoff(attempt, c.opt.MinRetryBackoff, c.opt.MaxRetryBackoff)
}

// PoolStats returns accumulated connection pool stats.
func (c *Ring) PoolStats() *PoolStats {
        // note: `c.List()` return a shadow copy of `[]*ringShard`.
        shards := c.sharding.List()
        var acc PoolStats
        for _, shard := range shards {
                s := shard.Client.connPool.Stats()
                acc.Hits += s.Hits
                acc.Misses += s.Misses
                acc.Timeouts += s.Timeouts
                acc.TotalConns += s.TotalConns
                acc.IdleConns += s.IdleConns
        }
        return &acc
}

// Len returns the current number of shards in the ring.
func (c *Ring) Len() int {
        return c.sharding.Len()
}

// Subscribe subscribes the client to the specified channels.
func (c *Ring) Subscribe(ctx context.Context, channels ...string) *PubSub {
        if len(channels) == 0 {
                panic("at least one channel is required")
        }

        shard, err := c.sharding.GetByKey(channels[0])
        if err != nil {
                // TODO: return PubSub with sticky error
                panic(err)
        }
        return shard.Client.Subscribe(ctx, channels...)
}

// PSubscribe subscribes the client to the given patterns.
func (c *Ring) PSubscribe(ctx context.Context, channels ...string) *PubSub {
        if len(channels) == 0 {
                panic("at least one channel is required")
        }

        shard, err := c.sharding.GetByKey(channels[0])
        if err != nil {
                // TODO: return PubSub with sticky error
                panic(err)
        }
        return shard.Client.PSubscribe(ctx, channels...)
}

// SSubscribe Subscribes the client to the specified shard channels.
func (c *Ring) SSubscribe(ctx context.Context, channels ...string) *PubSub {
        if len(channels) == 0 {
                panic("at least one channel is required")
        }
        shard, err := c.sharding.GetByKey(channels[0])
        if err != nil {
                // TODO: return PubSub with sticky error
                panic(err)
        }
        return shard.Client.SSubscribe(ctx, channels...)
}

func (c *Ring) OnNewNode(fn func(rdb *Client)) {
        c.sharding.OnNewNode(fn)
}

// ForEachShard concurrently calls the fn on each live shard in the ring.
// It returns the first error if any.
func (c *Ring) ForEachShard(
        ctx context.Context,
        fn func(ctx context.Context, client *Client) error,
) error {
        // note: `c.List()` return a shadow copy of `[]*ringShard`.
        shards := c.sharding.List()
        var wg sync.WaitGroup
        errCh := make(chan error, 1)
        for _, shard := range shards {
                if shard.IsDown() {
                        continue
                }

                wg.Add(1)
                go func(shard *ringShard) {
                        defer wg.Done()
                        err := fn(ctx, shard.Client)
                        if err != nil {
                                select {
                                case errCh <- err:
                                default:
                                }
                        }
                }(shard)
        }
        wg.Wait()

        select {
        case err := <-errCh:
                return err
        default:
                return nil
        }
}

func (c *Ring) cmdsInfo(ctx context.Context) (map[string]*CommandInfo, error) {
        // note: `c.List()` return a shadow copy of `[]*ringShard`.
        shards := c.sharding.List()
        var firstErr error
        for _, shard := range shards {
                cmdsInfo, err := shard.Client.Command(ctx).Result()
                if err == nil {
                        return cmdsInfo, nil
                }
                if firstErr == nil {
                        firstErr = err
                }
        }
        if firstErr == nil {
                return nil, errRingShardsDown
        }
        return nil, firstErr
}

func (c *Ring) cmdShard(cmd Cmder) (*ringShard, error) {
        pos := cmdFirstKeyPos(cmd)
        if pos == 0 {
                return c.sharding.Random()
        }
        firstKey := cmd.stringArg(pos)
        return c.sharding.GetByKey(firstKey)
}

func (c *Ring) process(ctx context.Context, cmd Cmder) error {
        var lastErr error
        for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
                if attempt > 0 {
                        if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
                                return err
                        }
                }

                shard, err := c.cmdShard(cmd)
                if err != nil {
                        return err
                }

                lastErr = shard.Client.Process(ctx, cmd)
                if lastErr == nil || !shouldRetry(lastErr, cmd.readTimeout() == nil) {
                        return lastErr
                }
        }
        return lastErr
}

func (c *Ring) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.Pipeline().Pipelined(ctx, fn)
}

func (c *Ring) Pipeline() Pipeliner {
        pipe := Pipeline{
                exec: pipelineExecer(c.processPipelineHook),
        }
        pipe.init()
        return &pipe
}

func (c *Ring) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.TxPipeline().Pipelined(ctx, fn)
}

func (c *Ring) TxPipeline() Pipeliner {
        pipe := Pipeline{
                exec: func(ctx context.Context, cmds []Cmder) error {
                        cmds = wrapMultiExec(ctx, cmds)
                        return c.processTxPipelineHook(ctx, cmds)
                },
        }
        pipe.init()
        return &pipe
}

func (c *Ring) generalProcessPipeline(
        ctx context.Context, cmds []Cmder, tx bool,
) error {
        if tx {
                // Trim multi .. exec.
                cmds = cmds[1 : len(cmds)-1]
        }

        cmdsMap := make(map[string][]Cmder)

        for _, cmd := range cmds {
                hash := cmd.stringArg(cmdFirstKeyPos(cmd))
                if hash != "" {
                        hash = c.sharding.Hash(hash)
                }
                cmdsMap[hash] = append(cmdsMap[hash], cmd)
        }

        var wg sync.WaitGroup
        errs := make(chan error, len(cmdsMap))

        for hash, cmds := range cmdsMap {
                wg.Add(1)
                go func(hash string, cmds []Cmder) {
                        defer wg.Done()

                        // TODO: retry?
                        shard, err := c.sharding.GetByName(hash)
                        if err != nil {
                                setCmdsErr(cmds, err)
                                return
                        }

                        hook := shard.Client.processPipelineHook
                        if tx {
                                cmds = wrapMultiExec(ctx, cmds)
                                hook = shard.Client.processTxPipelineHook
                        }

                        if err = hook(ctx, cmds); err != nil {
                                errs <- err
                        }
                }(hash, cmds)
        }

        wg.Wait()
        close(errs)

        if err := <-errs; err != nil {
                return err
        }
        return cmdsFirstErr(cmds)
}

func (c *Ring) Watch(ctx context.Context, fn func(*Tx) error, keys ...string) error {
        if len(keys) == 0 {
                return fmt.Errorf("redis: Watch requires at least one key")
        }

        var shards []*ringShard

        for _, key := range keys {
                if key != "" {
                        shard, err := c.sharding.GetByKey(key)
                        if err != nil {
                                return err
                        }

                        shards = append(shards, shard)
                }
        }

        if len(shards) == 0 {
                return fmt.Errorf("redis: Watch requires at least one shard")
        }

        if len(shards) > 1 {
                for _, shard := range shards[1:] {
                        if shard.Client != shards[0].Client {
                                err := fmt.Errorf("redis: Watch requires all keys to be in the same shard")
                                return err
                        }
                }
        }

        return shards[0].Client.Watch(ctx, fn, keys...)
}

// Close closes the ring client, releasing any open resources.
//
// It is rare to Close a Ring, as the Ring is meant to be long-lived
// and shared between many goroutines.
func (c *Ring) Close() error {
        c.heartbeatCancelFn()

        return c.sharding.Close()
}

// GetShardClients returns a list of all shard clients in the ring.
// This can be used to create dedicated connections (e.g., PubSub) for each shard.
func (c *Ring) GetShardClients() []*Client {
        shards := c.sharding.List()
        clients := make([]*Client, 0, len(shards))
        for _, shard := range shards {
                if shard.IsUp() {
                        clients = append(clients, shard.Client)
                }
        }
        return clients
}

// GetShardClientForKey returns the shard client that would handle the given key.
// This can be used to determine which shard a particular key/channel would be routed to.
func (c *Ring) GetShardClientForKey(key string) (*Client, error) {
        shard, err := c.sharding.GetByKey(key)
        if err != nil {
                return nil, err
        }
        return shard.Client, nil
}

package redis

import (
        "context"
        "crypto/sha1"
        "encoding/hex"
        "io"
)

type Scripter interface {
        Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
        EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
        EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
        EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
        ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd
        ScriptLoad(ctx context.Context, script string) *StringCmd
}

var (
        _ Scripter = (*Client)(nil)
        _ Scripter = (*Ring)(nil)
        _ Scripter = (*ClusterClient)(nil)
)

type Script struct {
        src, hash string
}

func NewScript(src string) *Script {
        h := sha1.New()
        _, _ = io.WriteString(h, src)
        return &Script{
                src:  src,
                hash: hex.EncodeToString(h.Sum(nil)),
        }
}

func (s *Script) Hash() string {
        return s.hash
}

func (s *Script) Load(ctx context.Context, c Scripter) *StringCmd {
        return c.ScriptLoad(ctx, s.src)
}

func (s *Script) Exists(ctx context.Context, c Scripter) *BoolSliceCmd {
        return c.ScriptExists(ctx, s.hash)
}

func (s *Script) Eval(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
        return c.Eval(ctx, s.src, keys, args...)
}

func (s *Script) EvalRO(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
        return c.EvalRO(ctx, s.src, keys, args...)
}

func (s *Script) EvalSha(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
        return c.EvalSha(ctx, s.hash, keys, args...)
}

func (s *Script) EvalShaRO(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
        return c.EvalShaRO(ctx, s.hash, keys, args...)
}

// Run optimistically uses EVALSHA to run the script. If script does not exist
// it is retried using EVAL.
func (s *Script) Run(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
        r := s.EvalSha(ctx, c, keys, args...)
        if HasErrorPrefix(r.Err(), "NOSCRIPT") {
                return s.Eval(ctx, c, keys, args...)
        }
        return r
}

// RunRO optimistically uses EVALSHA_RO to run the script. If script does not exist
// it is retried using EVAL_RO.
func (s *Script) RunRO(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
        r := s.EvalShaRO(ctx, c, keys, args...)
        if HasErrorPrefix(r.Err(), "NOSCRIPT") {
                return s.EvalRO(ctx, c, keys, args...)
        }
        return r
}

package redis

import "context"

type ScriptingFunctionsCmdable interface {
        Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
        EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
        EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
        EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
        ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd
        ScriptFlush(ctx context.Context) *StatusCmd
        ScriptKill(ctx context.Context) *StatusCmd
        ScriptLoad(ctx context.Context, script string) *StringCmd

        FunctionLoad(ctx context.Context, code string) *StringCmd
        FunctionLoadReplace(ctx context.Context, code string) *StringCmd
        FunctionDelete(ctx context.Context, libName string) *StringCmd
        FunctionFlush(ctx context.Context) *StringCmd
        FunctionKill(ctx context.Context) *StringCmd
        FunctionFlushAsync(ctx context.Context) *StringCmd
        FunctionList(ctx context.Context, q FunctionListQuery) *FunctionListCmd
        FunctionDump(ctx context.Context) *StringCmd
        FunctionRestore(ctx context.Context, libDump string) *StringCmd
        FunctionStats(ctx context.Context) *FunctionStatsCmd
        FCall(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
        FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
        FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
}

func (c cmdable) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd {
        return c.eval(ctx, "eval", script, keys, args...)
}

func (c cmdable) EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd {
        return c.eval(ctx, "eval_ro", script, keys, args...)
}

func (c cmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd {
        return c.eval(ctx, "evalsha", sha1, keys, args...)
}

func (c cmdable) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd {
        return c.eval(ctx, "evalsha_ro", sha1, keys, args...)
}

func (c cmdable) eval(ctx context.Context, name, payload string, keys []string, args ...interface{}) *Cmd {
        cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))
        cmdArgs[0] = name
        cmdArgs[1] = payload
        cmdArgs[2] = len(keys)
        for i, key := range keys {
                cmdArgs[3+i] = key
        }
        cmdArgs = appendArgs(cmdArgs, args)
        cmd := NewCmd(ctx, cmdArgs...)

        // it is possible that only args exist without a key.
        // rdb.eval(ctx, eval, script, nil, arg1, arg2)
        if len(keys) > 0 {
                cmd.SetFirstKeyPos(3)
        }
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
        args := make([]interface{}, 2+len(hashes))
        args[0] = "script"
        args[1] = "exists"
        for i, hash := range hashes {
                args[2+i] = hash
        }
        cmd := NewBoolSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ScriptFlush(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "script", "flush")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ScriptKill(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "script", "kill")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ScriptLoad(ctx context.Context, script string) *StringCmd {
        cmd := NewStringCmd(ctx, "script", "load", script)
        _ = c(ctx, cmd)
        return cmd
}

// ------------------------------------------------------------------------------

// FunctionListQuery is used with FunctionList to query for Redis libraries
//
//                  LibraryNamePattern         - Use an empty string to get all libraries.
//                                                          - Use a glob-style pattern to match multiple libraries with a matching name
//                                                          - Use a library's full name to match a single library
//                WithCode                        - If true, it will return the code of the library
type FunctionListQuery struct {
        LibraryNamePattern string
        WithCode           bool
}

func (c cmdable) FunctionLoad(ctx context.Context, code string) *StringCmd {
        cmd := NewStringCmd(ctx, "function", "load", code)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionLoadReplace(ctx context.Context, code string) *StringCmd {
        cmd := NewStringCmd(ctx, "function", "load", "replace", code)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionDelete(ctx context.Context, libName string) *StringCmd {
        cmd := NewStringCmd(ctx, "function", "delete", libName)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionFlush(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "function", "flush")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionKill(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "function", "kill")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionFlushAsync(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "function", "flush", "async")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionList(ctx context.Context, q FunctionListQuery) *FunctionListCmd {
        args := make([]interface{}, 2, 5)
        args[0] = "function"
        args[1] = "list"
        if q.LibraryNamePattern != "" {
                args = append(args, "libraryname", q.LibraryNamePattern)
        }
        if q.WithCode {
                args = append(args, "withcode")
        }
        cmd := NewFunctionListCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionDump(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "function", "dump")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionRestore(ctx context.Context, libDump string) *StringCmd {
        cmd := NewStringCmd(ctx, "function", "restore", libDump)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FunctionStats(ctx context.Context) *FunctionStatsCmd {
        cmd := NewFunctionStatsCmd(ctx, "function", "stats")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) FCall(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
        cmdArgs := fcallArgs("fcall", function, keys, args...)
        cmd := NewCmd(ctx, cmdArgs...)
        if len(keys) > 0 {
                cmd.SetFirstKeyPos(3)
        }
        _ = c(ctx, cmd)
        return cmd
}

// FCallRo this function simply calls FCallRO,
// Deprecated: to maintain convention FCallRO.
func (c cmdable) FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
        return c.FCallRO(ctx, function, keys, args...)
}

func (c cmdable) FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
        cmdArgs := fcallArgs("fcall_ro", function, keys, args...)
        cmd := NewCmd(ctx, cmdArgs...)
        if len(keys) > 0 {
                cmd.SetFirstKeyPos(3)
        }
        _ = c(ctx, cmd)
        return cmd
}

func fcallArgs(command string, function string, keys []string, args ...interface{}) []interface{} {
        cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))
        cmdArgs[0] = command
        cmdArgs[1] = function
        cmdArgs[2] = len(keys)
        for i, key := range keys {
                cmdArgs[3+i] = key
        }

        cmdArgs = append(cmdArgs, args...)
        return cmdArgs
}

package redis

import (
        "context"
        "fmt"
        "strconv"

        "github.com/redis/go-redis/v9/internal"
        "github.com/redis/go-redis/v9/internal/proto"
)

type SearchCmdable interface {
        FT_List(ctx context.Context) *StringSliceCmd
        FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd
        FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd
        FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd
        FTAliasDel(ctx context.Context, alias string) *StatusCmd
        FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd
        FTAlter(ctx context.Context, index string, skipInitialScan bool, definition []interface{}) *StatusCmd
        FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd
        FTConfigSet(ctx context.Context, option string, value interface{}) *StatusCmd
        FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd
        FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd
        FTCursorRead(ctx context.Context, index string, cursorId int, count int) *MapStringInterfaceCmd
        FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd
        FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd
        FTDictDump(ctx context.Context, dict string) *StringSliceCmd
        FTDropIndex(ctx context.Context, index string) *StatusCmd
        FTDropIndexWithArgs(ctx context.Context, index string, options *FTDropIndexOptions) *StatusCmd
        FTExplain(ctx context.Context, index string, query string) *StringCmd
        FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd
        FTInfo(ctx context.Context, index string) *FTInfoCmd
        FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd
        FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd
        FTSearch(ctx context.Context, index string, query string) *FTSearchCmd
        FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd
        FTSynDump(ctx context.Context, index string) *FTSynDumpCmd
        FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd
        FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *FTSynUpdateOptions, terms []interface{}) *StatusCmd
        FTTagVals(ctx context.Context, index string, field string) *StringSliceCmd
}

type FTCreateOptions struct {
        OnHash          bool
        OnJSON          bool
        Prefix          []interface{}
        Filter          string
        DefaultLanguage string
        LanguageField   string
        Score           float64
        ScoreField      string
        PayloadField    string
        MaxTextFields   int
        NoOffsets       bool
        Temporary       int
        NoHL            bool
        NoFields        bool
        NoFreqs         bool
        StopWords       []interface{}
        SkipInitialScan bool
}

type FieldSchema struct {
        FieldName         string
        As                string
        FieldType         SearchFieldType
        Sortable          bool
        UNF               bool
        NoStem            bool
        NoIndex           bool
        PhoneticMatcher   string
        Weight            float64
        Separator         string
        CaseSensitive     bool
        WithSuffixtrie    bool
        VectorArgs        *FTVectorArgs
        GeoShapeFieldType string
        IndexEmpty        bool
        IndexMissing      bool
}

type FTVectorArgs struct {
        FlatOptions *FTFlatOptions
        HNSWOptions *FTHNSWOptions
}

type FTFlatOptions struct {
        Type            string
        Dim             int
        DistanceMetric  string
        InitialCapacity int
        BlockSize       int
}

type FTHNSWOptions struct {
        Type                   string
        Dim                    int
        DistanceMetric         string
        InitialCapacity        int
        MaxEdgesPerNode        int
        MaxAllowedEdgesPerNode int
        EFRunTime              int
        Epsilon                float64
}

type FTDropIndexOptions struct {
        DeleteDocs bool
}

type SpellCheckTerms struct {
        Include    bool
        Exclude    bool
        Dictionary string
}

type FTExplainOptions struct {
        // Dialect 1,3 and 4 are deprecated since redis 8.0
        Dialect string
}

type FTSynUpdateOptions struct {
        SkipInitialScan bool
}

type SearchAggregator int

const (
        SearchInvalid = SearchAggregator(iota)
        SearchAvg
        SearchSum
        SearchMin
        SearchMax
        SearchCount
        SearchCountDistinct
        SearchCountDistinctish
        SearchStdDev
        SearchQuantile
        SearchToList
        SearchFirstValue
        SearchRandomSample
)

func (a SearchAggregator) String() string {
        switch a {
        case SearchInvalid:
                return ""
        case SearchAvg:
                return "AVG"
        case SearchSum:
                return "SUM"
        case SearchMin:
                return "MIN"
        case SearchMax:
                return "MAX"
        case SearchCount:
                return "COUNT"
        case SearchCountDistinct:
                return "COUNT_DISTINCT"
        case SearchCountDistinctish:
                return "COUNT_DISTINCTISH"
        case SearchStdDev:
                return "STDDEV"
        case SearchQuantile:
                return "QUANTILE"
        case SearchToList:
                return "TOLIST"
        case SearchFirstValue:
                return "FIRST_VALUE"
        case SearchRandomSample:
                return "RANDOM_SAMPLE"
        default:
                return ""
        }
}

type SearchFieldType int

const (
        SearchFieldTypeInvalid = SearchFieldType(iota)
        SearchFieldTypeNumeric
        SearchFieldTypeTag
        SearchFieldTypeText
        SearchFieldTypeGeo
        SearchFieldTypeVector
        SearchFieldTypeGeoShape
)

func (t SearchFieldType) String() string {
        switch t {
        case SearchFieldTypeInvalid:
                return ""
        case SearchFieldTypeNumeric:
                return "NUMERIC"
        case SearchFieldTypeTag:
                return "TAG"
        case SearchFieldTypeText:
                return "TEXT"
        case SearchFieldTypeGeo:
                return "GEO"
        case SearchFieldTypeVector:
                return "VECTOR"
        case SearchFieldTypeGeoShape:
                return "GEOSHAPE"
        default:
                return "TEXT"
        }
}

// Each AggregateReducer have different args.
// Please follow https://redis.io/docs/interact/search-and-query/search/aggregations/#supported-groupby-reducers for more information.
type FTAggregateReducer struct {
        Reducer SearchAggregator
        Args    []interface{}
        As      string
}

type FTAggregateGroupBy struct {
        Fields []interface{}
        Reduce []FTAggregateReducer
}

type FTAggregateSortBy struct {
        FieldName string
        Asc       bool
        Desc      bool
}

type FTAggregateApply struct {
        Field string
        As    string
}

type FTAggregateLoad struct {
        Field string
        As    string
}

type FTAggregateWithCursor struct {
        Count   int
        MaxIdle int
}

type FTAggregateOptions struct {
        Verbatim  bool
        LoadAll   bool
        Load      []FTAggregateLoad
        Timeout   int
        GroupBy   []FTAggregateGroupBy
        SortBy    []FTAggregateSortBy
        SortByMax int
        // Scorer is used to set scoring function, if not set passed, a default will be used.
        // The default scorer depends on the Redis version:
        // - `BM25` for Redis >= 8
        // - `TFIDF` for Redis < 8
        Scorer string
        // AddScores is available in Redis CE 8
        AddScores         bool
        Apply             []FTAggregateApply
        LimitOffset       int
        Limit             int
        Filter            string
        WithCursor        bool
        WithCursorOptions *FTAggregateWithCursor
        Params            map[string]interface{}
        // Dialect 1,3 and 4 are deprecated since redis 8.0
        DialectVersion int
}

type FTSearchFilter struct {
        FieldName interface{}
        Min       interface{}
        Max       interface{}
}

type FTSearchGeoFilter struct {
        FieldName string
        Longitude float64
        Latitude  float64
        Radius    float64
        Unit      string
}

type FTSearchReturn struct {
        FieldName string
        As        string
}

type FTSearchSortBy struct {
        FieldName string
        Asc       bool
        Desc      bool
}

// FTSearchOptions hold options that can be passed to the FT.SEARCH command.
// More information about the options can be found
// in the documentation for FT.SEARCH https://redis.io/docs/latest/commands/ft.search/
type FTSearchOptions struct {
        NoContent    bool
        Verbatim     bool
        NoStopWords  bool
        WithScores   bool
        WithPayloads bool
        WithSortKeys bool
        Filters      []FTSearchFilter
        GeoFilter    []FTSearchGeoFilter
        InKeys       []interface{}
        InFields     []interface{}
        Return       []FTSearchReturn
        Slop         int
        Timeout      int
        InOrder      bool
        Language     string
        Expander     string
        // Scorer is used to set scoring function, if not set passed, a default will be used.
        // The default scorer depends on the Redis version:
        // - `BM25` for Redis >= 8
        // - `TFIDF` for Redis < 8
        Scorer          string
        ExplainScore    bool
        Payload         string
        SortBy          []FTSearchSortBy
        SortByWithCount bool
        LimitOffset     int
        Limit           int
        // CountOnly sets LIMIT 0 0 to get the count - number of documents in the result set without actually returning the result set.
        // When using this option, the Limit and LimitOffset options are ignored.
        CountOnly bool
        Params    map[string]interface{}
        // Dialect 1,3 and 4 are deprecated since redis 8.0
        DialectVersion int
}

type FTSynDumpResult struct {
        Term     string
        Synonyms []string
}

type FTSynDumpCmd struct {
        baseCmd
        val []FTSynDumpResult
}

type FTAggregateResult struct {
        Total int
        Rows  []AggregateRow
}

type AggregateRow struct {
        Fields map[string]interface{}
}

type AggregateCmd struct {
        baseCmd
        val *FTAggregateResult
}

type FTInfoResult struct {
        IndexErrors              IndexErrors
        Attributes               []FTAttribute
        BytesPerRecordAvg        string
        Cleaning                 int
        CursorStats              CursorStats
        DialectStats             map[string]int
        DocTableSizeMB           float64
        FieldStatistics          []FieldStatistic
        GCStats                  GCStats
        GeoshapesSzMB            float64
        HashIndexingFailures     int
        IndexDefinition          IndexDefinition
        IndexName                string
        IndexOptions             []string
        Indexing                 int
        InvertedSzMB             float64
        KeyTableSizeMB           float64
        MaxDocID                 int
        NumDocs                  int
        NumRecords               int
        NumTerms                 int
        NumberOfUses             int
        OffsetBitsPerRecordAvg   string
        OffsetVectorsSzMB        float64
        OffsetsPerTermAvg        string
        PercentIndexed           float64
        RecordsPerDocAvg         string
        SortableValuesSizeMB     float64
        TagOverheadSzMB          float64
        TextOverheadSzMB         float64
        TotalIndexMemorySzMB     float64
        TotalIndexingTime        int
        TotalInvertedIndexBlocks int
        VectorIndexSzMB          float64
}

type IndexErrors struct {
        IndexingFailures     int
        LastIndexingError    string
        LastIndexingErrorKey string
}

type FTAttribute struct {
        Identifier      string
        Attribute       string
        Type            string
        Weight          float64
        Sortable        bool
        NoStem          bool
        NoIndex         bool
        UNF             bool
        PhoneticMatcher string
        CaseSensitive   bool
        WithSuffixtrie  bool
}

type CursorStats struct {
        GlobalIdle    int
        GlobalTotal   int
        IndexCapacity int
        IndexTotal    int
}

type FieldStatistic struct {
        Identifier  string
        Attribute   string
        IndexErrors IndexErrors
}

type GCStats struct {
        BytesCollected       int
        TotalMsRun           int
        TotalCycles          int
        AverageCycleTimeMs   string
        LastRunTimeMs        int
        GCNumericTreesMissed int
        GCBlocksDenied       int
}

type IndexDefinition struct {
        KeyType      string
        Prefixes     []string
        DefaultScore float64
}

type FTSpellCheckOptions struct {
        Distance int
        Terms    *FTSpellCheckTerms
        // Dialect 1,3 and 4 are deprecated since redis 8.0
        Dialect int
}

type FTSpellCheckTerms struct {
        Inclusion  string // Either "INCLUDE" or "EXCLUDE"
        Dictionary string
        Terms      []interface{}
}

type SpellCheckResult struct {
        Term        string
        Suggestions []SpellCheckSuggestion
}

type SpellCheckSuggestion struct {
        Score      float64
        Suggestion string
}

type FTSearchResult struct {
        Total int
        Docs  []Document
}

type Document struct {
        ID      string
        Score   *float64
        Payload *string
        SortKey *string
        Fields  map[string]string
}

type AggregateQuery []interface{}

// FT_List - Lists all the existing indexes in the database.
// For more information, please refer to the Redis documentation:
// [FT._LIST]: (https://redis.io/commands/ft._list/)
func (c cmdable) FT_List(ctx context.Context) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "FT._LIST")
        _ = c(ctx, cmd)
        return cmd
}

// FTAggregate - Performs a search query on an index and applies a series of aggregate transformations to the result.
// The 'index' parameter specifies the index to search, and the 'query' parameter specifies the search query.
// For more information, please refer to the Redis documentation:
// [FT.AGGREGATE]: (https://redis.io/commands/ft.aggregate/)
func (c cmdable) FTAggregate(ctx context.Context, index string, query string) *MapStringInterfaceCmd {
        args := []interface{}{"FT.AGGREGATE", index, query}
        cmd := NewMapStringInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func FTAggregateQuery(query string, options *FTAggregateOptions) AggregateQuery {
        queryArgs := []interface{}{query}
        if options != nil {
                if options.Verbatim {
                        queryArgs = append(queryArgs, "VERBATIM")
                }

                if options.Scorer != "" {
                        queryArgs = append(queryArgs, "SCORER", options.Scorer)
                }

                if options.AddScores {
                        queryArgs = append(queryArgs, "ADDSCORES")
                }

                if options.LoadAll && options.Load != nil {
                        panic("FT.AGGREGATE: LOADALL and LOAD are mutually exclusive")
                }
                if options.LoadAll {
                        queryArgs = append(queryArgs, "LOAD", "*")
                }
                if options.Load != nil {
                        queryArgs = append(queryArgs, "LOAD", len(options.Load))
                        index, count := len(queryArgs)-1, 0
                        for _, load := range options.Load {
                                queryArgs = append(queryArgs, load.Field)
                                count++
                                if load.As != "" {
                                        queryArgs = append(queryArgs, "AS", load.As)
                                        count += 2
                                }
                        }
                        queryArgs[index] = count
                }

                if options.Timeout > 0 {
                        queryArgs = append(queryArgs, "TIMEOUT", options.Timeout)
                }

                for _, apply := range options.Apply {
                        queryArgs = append(queryArgs, "APPLY", apply.Field)
                        if apply.As != "" {
                                queryArgs = append(queryArgs, "AS", apply.As)
                        }
                }

                if options.GroupBy != nil {
                        for _, groupBy := range options.GroupBy {
                                queryArgs = append(queryArgs, "GROUPBY", len(groupBy.Fields))
                                queryArgs = append(queryArgs, groupBy.Fields...)

                                for _, reducer := range groupBy.Reduce {
                                        queryArgs = append(queryArgs, "REDUCE")
                                        queryArgs = append(queryArgs, reducer.Reducer.String())
                                        if reducer.Args != nil {
                                                queryArgs = append(queryArgs, len(reducer.Args))
                                                queryArgs = append(queryArgs, reducer.Args...)
                                        } else {
                                                queryArgs = append(queryArgs, 0)
                                        }
                                        if reducer.As != "" {
                                                queryArgs = append(queryArgs, "AS", reducer.As)
                                        }
                                }
                        }
                }
                if options.SortBy != nil {
                        queryArgs = append(queryArgs, "SORTBY")
                        sortByOptions := []interface{}{}
                        for _, sortBy := range options.SortBy {
                                sortByOptions = append(sortByOptions, sortBy.FieldName)
                                if sortBy.Asc && sortBy.Desc {
                                        panic("FT.AGGREGATE: ASC and DESC are mutually exclusive")
                                }
                                if sortBy.Asc {
                                        sortByOptions = append(sortByOptions, "ASC")
                                }
                                if sortBy.Desc {
                                        sortByOptions = append(sortByOptions, "DESC")
                                }
                        }
                        queryArgs = append(queryArgs, len(sortByOptions))
                        queryArgs = append(queryArgs, sortByOptions...)
                }
                if options.SortByMax > 0 {
                        queryArgs = append(queryArgs, "MAX", options.SortByMax)
                }
                if options.LimitOffset >= 0 && options.Limit > 0 {
                        queryArgs = append(queryArgs, "LIMIT", options.LimitOffset, options.Limit)
                }
                if options.Filter != "" {
                        queryArgs = append(queryArgs, "FILTER", options.Filter)
                }
                if options.WithCursor {
                        queryArgs = append(queryArgs, "WITHCURSOR")
                        if options.WithCursorOptions != nil {
                                if options.WithCursorOptions.Count > 0 {
                                        queryArgs = append(queryArgs, "COUNT", options.WithCursorOptions.Count)
                                }
                                if options.WithCursorOptions.MaxIdle > 0 {
                                        queryArgs = append(queryArgs, "MAXIDLE", options.WithCursorOptions.MaxIdle)
                                }
                        }
                }
                if options.Params != nil {
                        queryArgs = append(queryArgs, "PARAMS", len(options.Params)*2)
                        for key, value := range options.Params {
                                queryArgs = append(queryArgs, key, value)
                        }
                }

                if options.DialectVersion > 0 {
                        queryArgs = append(queryArgs, "DIALECT", options.DialectVersion)
                } else {
                        queryArgs = append(queryArgs, "DIALECT", 2)
                }
        }
        return queryArgs
}

func ProcessAggregateResult(data []interface{}) (*FTAggregateResult, error) {
        if len(data) == 0 {
                return nil, fmt.Errorf("no data returned")
        }

        total, ok := data[0].(int64)
        if !ok {
                return nil, fmt.Errorf("invalid total format")
        }

        rows := make([]AggregateRow, 0, len(data)-1)
        for _, row := range data[1:] {
                fields, ok := row.([]interface{})
                if !ok {
                        return nil, fmt.Errorf("invalid row format")
                }

                rowMap := make(map[string]interface{})
                for i := 0; i < len(fields); i += 2 {
                        key, ok := fields[i].(string)
                        if !ok {
                                return nil, fmt.Errorf("invalid field key format")
                        }
                        value := fields[i+1]
                        rowMap[key] = value
                }
                rows = append(rows, AggregateRow{Fields: rowMap})
        }

        result := &FTAggregateResult{
                Total: int(total),
                Rows:  rows,
        }
        return result, nil
}

func NewAggregateCmd(ctx context.Context, args ...interface{}) *AggregateCmd {
        return &AggregateCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *AggregateCmd) SetVal(val *FTAggregateResult) {
        cmd.val = val
}

func (cmd *AggregateCmd) Val() *FTAggregateResult {
        return cmd.val
}

func (cmd *AggregateCmd) Result() (*FTAggregateResult, error) {
        return cmd.val, cmd.err
}

func (cmd *AggregateCmd) RawVal() interface{} {
        return cmd.rawVal
}

func (cmd *AggregateCmd) RawResult() (interface{}, error) {
        return cmd.rawVal, cmd.err
}

func (cmd *AggregateCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *AggregateCmd) readReply(rd *proto.Reader) (err error) {
        data, err := rd.ReadSlice()
        if err != nil {
                return err
        }
        cmd.val, err = ProcessAggregateResult(data)
        if err != nil {
                return err
        }
        return nil
}

// FTAggregateWithArgs - Performs a search query on an index and applies a series of aggregate transformations to the result.
// The 'index' parameter specifies the index to search, and the 'query' parameter specifies the search query.
// This function also allows for specifying additional options such as: Verbatim, LoadAll, Load, Timeout, GroupBy, SortBy, SortByMax, Apply, LimitOffset, Limit, Filter, WithCursor, Params, and DialectVersion.
// For more information, please refer to the Redis documentation:
// [FT.AGGREGATE]: (https://redis.io/commands/ft.aggregate/)
func (c cmdable) FTAggregateWithArgs(ctx context.Context, index string, query string, options *FTAggregateOptions) *AggregateCmd {
        args := []interface{}{"FT.AGGREGATE", index, query}
        if options != nil {
                if options.Verbatim {
                        args = append(args, "VERBATIM")
                }
                if options.Scorer != "" {
                        args = append(args, "SCORER", options.Scorer)
                }
                if options.AddScores {
                        args = append(args, "ADDSCORES")
                }
                if options.LoadAll && options.Load != nil {
                        panic("FT.AGGREGATE: LOADALL and LOAD are mutually exclusive")
                }
                if options.LoadAll {
                        args = append(args, "LOAD", "*")
                }
                if options.Load != nil {
                        args = append(args, "LOAD", len(options.Load))
                        index, count := len(args)-1, 0
                        for _, load := range options.Load {
                                args = append(args, load.Field)
                                count++
                                if load.As != "" {
                                        args = append(args, "AS", load.As)
                                        count += 2
                                }
                        }
                        args[index] = count
                }
                if options.Timeout > 0 {
                        args = append(args, "TIMEOUT", options.Timeout)
                }
                for _, apply := range options.Apply {
                        args = append(args, "APPLY", apply.Field)
                        if apply.As != "" {
                                args = append(args, "AS", apply.As)
                        }
                }
                if options.GroupBy != nil {
                        for _, groupBy := range options.GroupBy {
                                args = append(args, "GROUPBY", len(groupBy.Fields))
                                args = append(args, groupBy.Fields...)

                                for _, reducer := range groupBy.Reduce {
                                        args = append(args, "REDUCE")
                                        args = append(args, reducer.Reducer.String())
                                        if reducer.Args != nil {
                                                args = append(args, len(reducer.Args))
                                                args = append(args, reducer.Args...)
                                        } else {
                                                args = append(args, 0)
                                        }
                                        if reducer.As != "" {
                                                args = append(args, "AS", reducer.As)
                                        }
                                }
                        }
                }
                if options.SortBy != nil {
                        args = append(args, "SORTBY")
                        sortByOptions := []interface{}{}
                        for _, sortBy := range options.SortBy {
                                sortByOptions = append(sortByOptions, sortBy.FieldName)
                                if sortBy.Asc && sortBy.Desc {
                                        panic("FT.AGGREGATE: ASC and DESC are mutually exclusive")
                                }
                                if sortBy.Asc {
                                        sortByOptions = append(sortByOptions, "ASC")
                                }
                                if sortBy.Desc {
                                        sortByOptions = append(sortByOptions, "DESC")
                                }
                        }
                        args = append(args, len(sortByOptions))
                        args = append(args, sortByOptions...)
                }
                if options.SortByMax > 0 {
                        args = append(args, "MAX", options.SortByMax)
                }
                if options.LimitOffset >= 0 && options.Limit > 0 {
                        args = append(args, "LIMIT", options.LimitOffset, options.Limit)
                }
                if options.Filter != "" {
                        args = append(args, "FILTER", options.Filter)
                }
                if options.WithCursor {
                        args = append(args, "WITHCURSOR")
                        if options.WithCursorOptions != nil {
                                if options.WithCursorOptions.Count > 0 {
                                        args = append(args, "COUNT", options.WithCursorOptions.Count)
                                }
                                if options.WithCursorOptions.MaxIdle > 0 {
                                        args = append(args, "MAXIDLE", options.WithCursorOptions.MaxIdle)
                                }
                        }
                }
                if options.Params != nil {
                        args = append(args, "PARAMS", len(options.Params)*2)
                        for key, value := range options.Params {
                                args = append(args, key, value)
                        }
                }
                if options.DialectVersion > 0 {
                        args = append(args, "DIALECT", options.DialectVersion)
                } else {
                        args = append(args, "DIALECT", 2)
                }
        }

        cmd := NewAggregateCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTAliasAdd - Adds an alias to an index.
// The 'index' parameter specifies the index to which the alias is added, and the 'alias' parameter specifies the alias.
// For more information, please refer to the Redis documentation:
// [FT.ALIASADD]: (https://redis.io/commands/ft.aliasadd/)
func (c cmdable) FTAliasAdd(ctx context.Context, index string, alias string) *StatusCmd {
        args := []interface{}{"FT.ALIASADD", alias, index}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTAliasDel - Removes an alias from an index.
// The 'alias' parameter specifies the alias to be removed.
// For more information, please refer to the Redis documentation:
// [FT.ALIASDEL]: (https://redis.io/commands/ft.aliasdel/)
func (c cmdable) FTAliasDel(ctx context.Context, alias string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "FT.ALIASDEL", alias)
        _ = c(ctx, cmd)
        return cmd
}

// FTAliasUpdate - Updates an alias to an index.
// The 'index' parameter specifies the index to which the alias is updated, and the 'alias' parameter specifies the alias.
// If the alias already exists for a different index, it updates the alias to point to the specified index instead.
// For more information, please refer to the Redis documentation:
// [FT.ALIASUPDATE]: (https://redis.io/commands/ft.aliasupdate/)
func (c cmdable) FTAliasUpdate(ctx context.Context, index string, alias string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "FT.ALIASUPDATE", alias, index)
        _ = c(ctx, cmd)
        return cmd
}

// FTAlter - Alters the definition of an existing index.
// The 'index' parameter specifies the index to alter, and the 'skipInitialScan' parameter specifies whether to skip the initial scan.
// The 'definition' parameter specifies the new definition for the index.
// For more information, please refer to the Redis documentation:
// [FT.ALTER]: (https://redis.io/commands/ft.alter/)
func (c cmdable) FTAlter(ctx context.Context, index string, skipInitialScan bool, definition []interface{}) *StatusCmd {
        args := []interface{}{"FT.ALTER", index}
        if skipInitialScan {
                args = append(args, "SKIPINITIALSCAN")
        }
        args = append(args, "SCHEMA", "ADD")
        args = append(args, definition...)
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// Retrieves the value of a RediSearch configuration parameter.
// The 'option' parameter specifies the configuration parameter to retrieve.
// For more information, please refer to the Redis [FT.CONFIG GET] documentation.
//
// Deprecated: FTConfigGet is deprecated in Redis 8.
// All configuration will be done with the CONFIG GET command.
// For more information check [Client.ConfigGet] and [CONFIG GET Documentation]
//
// [CONFIG GET Documentation]: https://redis.io/commands/config-get/
// [FT.CONFIG GET]: https://redis.io/commands/ft.config-get/
func (c cmdable) FTConfigGet(ctx context.Context, option string) *MapMapStringInterfaceCmd {
        cmd := NewMapMapStringInterfaceCmd(ctx, "FT.CONFIG", "GET", option)
        _ = c(ctx, cmd)
        return cmd
}

// Sets the value of a RediSearch configuration parameter.
// The 'option' parameter specifies the configuration parameter to set, and the 'value' parameter specifies the new value.
// For more information, please refer to the Redis [FT.CONFIG SET] documentation.
//
// Deprecated: FTConfigSet is deprecated in Redis 8.
// All configuration will be done with the CONFIG SET command.
// For more information check [Client.ConfigSet] and [CONFIG SET Documentation]
//
// [CONFIG SET Documentation]: https://redis.io/commands/config-set/
// [FT.CONFIG SET]: https://redis.io/commands/ft.config-set/
func (c cmdable) FTConfigSet(ctx context.Context, option string, value interface{}) *StatusCmd {
        cmd := NewStatusCmd(ctx, "FT.CONFIG", "SET", option, value)
        _ = c(ctx, cmd)
        return cmd
}

// FTCreate - Creates a new index with the given options and schema.
// The 'index' parameter specifies the name of the index to create.
// The 'options' parameter specifies various options for the index, such as:
// whether to index hashes or JSONs, prefixes, filters, default language, score, score field, payload field, etc.
// The 'schema' parameter specifies the schema for the index, which includes the field name, field type, etc.
// For more information, please refer to the Redis documentation:
// [FT.CREATE]: (https://redis.io/commands/ft.create/)
func (c cmdable) FTCreate(ctx context.Context, index string, options *FTCreateOptions, schema ...*FieldSchema) *StatusCmd {
        args := []interface{}{"FT.CREATE", index}
        if options != nil {
                if options.OnHash && !options.OnJSON {
                        args = append(args, "ON", "HASH")
                }
                if options.OnJSON && !options.OnHash {
                        args = append(args, "ON", "JSON")
                }
                if options.OnHash && options.OnJSON {
                        panic("FT.CREATE: ON HASH and ON JSON are mutually exclusive")
                }
                if options.Prefix != nil {
                        args = append(args, "PREFIX", len(options.Prefix))
                        args = append(args, options.Prefix...)
                }
                if options.Filter != "" {
                        args = append(args, "FILTER", options.Filter)
                }
                if options.DefaultLanguage != "" {
                        args = append(args, "LANGUAGE", options.DefaultLanguage)
                }
                if options.LanguageField != "" {
                        args = append(args, "LANGUAGE_FIELD", options.LanguageField)
                }
                if options.Score > 0 {
                        args = append(args, "SCORE", options.Score)
                }
                if options.ScoreField != "" {
                        args = append(args, "SCORE_FIELD", options.ScoreField)
                }
                if options.PayloadField != "" {
                        args = append(args, "PAYLOAD_FIELD", options.PayloadField)
                }
                if options.MaxTextFields > 0 {
                        args = append(args, "MAXTEXTFIELDS", options.MaxTextFields)
                }
                if options.NoOffsets {
                        args = append(args, "NOOFFSETS")
                }
                if options.Temporary > 0 {
                        args = append(args, "TEMPORARY", options.Temporary)
                }
                if options.NoHL {
                        args = append(args, "NOHL")
                }
                if options.NoFields {
                        args = append(args, "NOFIELDS")
                }
                if options.NoFreqs {
                        args = append(args, "NOFREQS")
                }
                if options.StopWords != nil {
                        args = append(args, "STOPWORDS", len(options.StopWords))
                        args = append(args, options.StopWords...)
                }
                if options.SkipInitialScan {
                        args = append(args, "SKIPINITIALSCAN")
                }
        }
        if schema == nil {
                panic("FT.CREATE: SCHEMA is required")
        }
        args = append(args, "SCHEMA")
        for _, schema := range schema {
                if schema.FieldName == "" || schema.FieldType == SearchFieldTypeInvalid {
                        panic("FT.CREATE: SCHEMA FieldName and FieldType are required")
                }
                args = append(args, schema.FieldName)
                if schema.As != "" {
                        args = append(args, "AS", schema.As)
                }
                args = append(args, schema.FieldType.String())
                if schema.VectorArgs != nil {
                        if schema.FieldType != SearchFieldTypeVector {
                                panic("FT.CREATE: SCHEMA FieldType VECTOR is required for VectorArgs")
                        }
                        if schema.VectorArgs.FlatOptions != nil && schema.VectorArgs.HNSWOptions != nil {
                                panic("FT.CREATE: SCHEMA VectorArgs FlatOptions and HNSWOptions are mutually exclusive")
                        }
                        if schema.VectorArgs.FlatOptions != nil {
                                args = append(args, "FLAT")
                                if schema.VectorArgs.FlatOptions.Type == "" || schema.VectorArgs.FlatOptions.Dim == 0 || schema.VectorArgs.FlatOptions.DistanceMetric == "" {
                                        panic("FT.CREATE: Type, Dim and DistanceMetric are required for VECTOR FLAT")
                                }
                                flatArgs := []interface{}{
                                        "TYPE", schema.VectorArgs.FlatOptions.Type,
                                        "DIM", schema.VectorArgs.FlatOptions.Dim,
                                        "DISTANCE_METRIC", schema.VectorArgs.FlatOptions.DistanceMetric,
                                }
                                if schema.VectorArgs.FlatOptions.InitialCapacity > 0 {
                                        flatArgs = append(flatArgs, "INITIAL_CAP", schema.VectorArgs.FlatOptions.InitialCapacity)
                                }
                                if schema.VectorArgs.FlatOptions.BlockSize > 0 {
                                        flatArgs = append(flatArgs, "BLOCK_SIZE", schema.VectorArgs.FlatOptions.BlockSize)
                                }
                                args = append(args, len(flatArgs))
                                args = append(args, flatArgs...)
                        }
                        if schema.VectorArgs.HNSWOptions != nil {
                                args = append(args, "HNSW")
                                if schema.VectorArgs.HNSWOptions.Type == "" || schema.VectorArgs.HNSWOptions.Dim == 0 || schema.VectorArgs.HNSWOptions.DistanceMetric == "" {
                                        panic("FT.CREATE: Type, Dim and DistanceMetric are required for VECTOR HNSW")
                                }
                                hnswArgs := []interface{}{
                                        "TYPE", schema.VectorArgs.HNSWOptions.Type,
                                        "DIM", schema.VectorArgs.HNSWOptions.Dim,
                                        "DISTANCE_METRIC", schema.VectorArgs.HNSWOptions.DistanceMetric,
                                }
                                if schema.VectorArgs.HNSWOptions.InitialCapacity > 0 {
                                        hnswArgs = append(hnswArgs, "INITIAL_CAP", schema.VectorArgs.HNSWOptions.InitialCapacity)
                                }
                                if schema.VectorArgs.HNSWOptions.MaxEdgesPerNode > 0 {
                                        hnswArgs = append(hnswArgs, "M", schema.VectorArgs.HNSWOptions.MaxEdgesPerNode)
                                }
                                if schema.VectorArgs.HNSWOptions.MaxAllowedEdgesPerNode > 0 {
                                        hnswArgs = append(hnswArgs, "EF_CONSTRUCTION", schema.VectorArgs.HNSWOptions.MaxAllowedEdgesPerNode)
                                }
                                if schema.VectorArgs.HNSWOptions.EFRunTime > 0 {
                                        hnswArgs = append(hnswArgs, "EF_RUNTIME", schema.VectorArgs.HNSWOptions.EFRunTime)
                                }
                                if schema.VectorArgs.HNSWOptions.Epsilon > 0 {
                                        hnswArgs = append(hnswArgs, "EPSILON", schema.VectorArgs.HNSWOptions.Epsilon)
                                }
                                args = append(args, len(hnswArgs))
                                args = append(args, hnswArgs...)
                        }
                }
                if schema.GeoShapeFieldType != "" {
                        if schema.FieldType != SearchFieldTypeGeoShape {
                                panic("FT.CREATE: SCHEMA FieldType GEOSHAPE is required for GeoShapeFieldType")
                        }
                        args = append(args, schema.GeoShapeFieldType)
                }
                if schema.NoStem {
                        args = append(args, "NOSTEM")
                }
                if schema.Sortable {
                        args = append(args, "SORTABLE")
                }
                if schema.UNF {
                        args = append(args, "UNF")
                }
                if schema.NoIndex {
                        args = append(args, "NOINDEX")
                }
                if schema.PhoneticMatcher != "" {
                        args = append(args, "PHONETIC", schema.PhoneticMatcher)
                }
                if schema.Weight > 0 {
                        args = append(args, "WEIGHT", schema.Weight)
                }
                if schema.Separator != "" {
                        args = append(args, "SEPARATOR", schema.Separator)
                }
                if schema.CaseSensitive {
                        args = append(args, "CASESENSITIVE")
                }
                if schema.WithSuffixtrie {
                        args = append(args, "WITHSUFFIXTRIE")
                }
                if schema.IndexEmpty {
                        args = append(args, "INDEXEMPTY")
                }
                if schema.IndexMissing {
                        args = append(args, "INDEXMISSING")

                }
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTCursorDel - Deletes a cursor from an existing index.
// The 'index' parameter specifies the index from which to delete the cursor, and the 'cursorId' parameter specifies the ID of the cursor to delete.
// For more information, please refer to the Redis documentation:
// [FT.CURSOR DEL]: (https://redis.io/commands/ft.cursor-del/)
func (c cmdable) FTCursorDel(ctx context.Context, index string, cursorId int) *StatusCmd {
        cmd := NewStatusCmd(ctx, "FT.CURSOR", "DEL", index, cursorId)
        _ = c(ctx, cmd)
        return cmd
}

// FTCursorRead - Reads the next results from an existing cursor.
// The 'index' parameter specifies the index from which to read the cursor, the 'cursorId' parameter specifies the ID of the cursor to read, and the 'count' parameter specifies the number of results to read.
// For more information, please refer to the Redis documentation:
// [FT.CURSOR READ]: (https://redis.io/commands/ft.cursor-read/)
func (c cmdable) FTCursorRead(ctx context.Context, index string, cursorId int, count int) *MapStringInterfaceCmd {
        args := []interface{}{"FT.CURSOR", "READ", index, cursorId}
        if count > 0 {
                args = append(args, "COUNT", count)
        }
        cmd := NewMapStringInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTDictAdd - Adds terms to a dictionary.
// The 'dict' parameter specifies the dictionary to which to add the terms, and the 'term' parameter specifies the terms to add.
// For more information, please refer to the Redis documentation:
// [FT.DICTADD]: (https://redis.io/commands/ft.dictadd/)
func (c cmdable) FTDictAdd(ctx context.Context, dict string, term ...interface{}) *IntCmd {
        args := []interface{}{"FT.DICTADD", dict}
        args = append(args, term...)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTDictDel - Deletes terms from a dictionary.
// The 'dict' parameter specifies the dictionary from which to delete the terms, and the 'term' parameter specifies the terms to delete.
// For more information, please refer to the Redis documentation:
// [FT.DICTDEL]: (https://redis.io/commands/ft.dictdel/)
func (c cmdable) FTDictDel(ctx context.Context, dict string, term ...interface{}) *IntCmd {
        args := []interface{}{"FT.DICTDEL", dict}
        args = append(args, term...)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTDictDump - Returns all terms in the specified dictionary.
// The 'dict' parameter specifies the dictionary from which to return the terms.
// For more information, please refer to the Redis documentation:
// [FT.DICTDUMP]: (https://redis.io/commands/ft.dictdump/)
func (c cmdable) FTDictDump(ctx context.Context, dict string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "FT.DICTDUMP", dict)
        _ = c(ctx, cmd)
        return cmd
}

// FTDropIndex - Deletes an index.
// The 'index' parameter specifies the index to delete.
// For more information, please refer to the Redis documentation:
// [FT.DROPINDEX]: (https://redis.io/commands/ft.dropindex/)
func (c cmdable) FTDropIndex(ctx context.Context, index string) *StatusCmd {
        args := []interface{}{"FT.DROPINDEX", index}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTDropIndexWithArgs - Deletes an index with options.
// The 'index' parameter specifies the index to delete, and the 'options' parameter specifies the DeleteDocs option for docs deletion.
// For more information, please refer to the Redis documentation:
// [FT.DROPINDEX]: (https://redis.io/commands/ft.dropindex/)
func (c cmdable) FTDropIndexWithArgs(ctx context.Context, index string, options *FTDropIndexOptions) *StatusCmd {
        args := []interface{}{"FT.DROPINDEX", index}
        if options != nil {
                if options.DeleteDocs {
                        args = append(args, "DD")
                }
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTExplain - Returns the execution plan for a complex query.
// The 'index' parameter specifies the index to query, and the 'query' parameter specifies the query string.
// For more information, please refer to the Redis documentation:
// [FT.EXPLAIN]: (https://redis.io/commands/ft.explain/)
func (c cmdable) FTExplain(ctx context.Context, index string, query string) *StringCmd {
        cmd := NewStringCmd(ctx, "FT.EXPLAIN", index, query)
        _ = c(ctx, cmd)
        return cmd
}

// FTExplainWithArgs - Returns the execution plan for a complex query with options.
// The 'index' parameter specifies the index to query, the 'query' parameter specifies the query string, and the 'options' parameter specifies the Dialect for the query.
// For more information, please refer to the Redis documentation:
// [FT.EXPLAIN]: (https://redis.io/commands/ft.explain/)
func (c cmdable) FTExplainWithArgs(ctx context.Context, index string, query string, options *FTExplainOptions) *StringCmd {
        args := []interface{}{"FT.EXPLAIN", index, query}
        if options.Dialect != "" {
                args = append(args, "DIALECT", options.Dialect)
        } else {
                args = append(args, "DIALECT", 2)
        }
        cmd := NewStringCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTExplainCli - Returns the execution plan for a complex query. [Not Implemented]
// For more information, see https://redis.io/commands/ft.explaincli/
func (c cmdable) FTExplainCli(ctx context.Context, key, path string) error {
        panic("not implemented")
}

func parseFTInfo(data map[string]interface{}) (FTInfoResult, error) {
        var ftInfo FTInfoResult
        // Manually parse each field from the map
        if indexErrors, ok := data["Index Errors"].([]interface{}); ok {
                ftInfo.IndexErrors = IndexErrors{
                        IndexingFailures:     internal.ToInteger(indexErrors[1]),
                        LastIndexingError:    internal.ToString(indexErrors[3]),
                        LastIndexingErrorKey: internal.ToString(indexErrors[5]),
                }
        }

        if attributes, ok := data["attributes"].([]interface{}); ok {
                for _, attr := range attributes {
                        if attrMap, ok := attr.([]interface{}); ok {
                                att := FTAttribute{}
                                for i := 0; i < len(attrMap); i++ {
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "attribute" {
                                                att.Attribute = internal.ToString(attrMap[i+1])
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "identifier" {
                                                att.Identifier = internal.ToString(attrMap[i+1])
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "type" {
                                                att.Type = internal.ToString(attrMap[i+1])
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "weight" {
                                                att.Weight = internal.ToFloat(attrMap[i+1])
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "nostem" {
                                                att.NoStem = true
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "sortable" {
                                                att.Sortable = true
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "noindex" {
                                                att.NoIndex = true
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "unf" {
                                                att.UNF = true
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "phonetic" {
                                                att.PhoneticMatcher = internal.ToString(attrMap[i+1])
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "case_sensitive" {
                                                att.CaseSensitive = true
                                                continue
                                        }
                                        if internal.ToLower(internal.ToString(attrMap[i])) == "withsuffixtrie" {
                                                att.WithSuffixtrie = true
                                                continue
                                        }

                                }
                                ftInfo.Attributes = append(ftInfo.Attributes, att)
                        }
                }
        }

        ftInfo.BytesPerRecordAvg = internal.ToString(data["bytes_per_record_avg"])
        ftInfo.Cleaning = internal.ToInteger(data["cleaning"])

        if cursorStats, ok := data["cursor_stats"].([]interface{}); ok {
                ftInfo.CursorStats = CursorStats{
                        GlobalIdle:    internal.ToInteger(cursorStats[1]),
                        GlobalTotal:   internal.ToInteger(cursorStats[3]),
                        IndexCapacity: internal.ToInteger(cursorStats[5]),
                        IndexTotal:    internal.ToInteger(cursorStats[7]),
                }
        }

        if dialectStats, ok := data["dialect_stats"].([]interface{}); ok {
                ftInfo.DialectStats = make(map[string]int)
                for i := 0; i < len(dialectStats); i += 2 {
                        ftInfo.DialectStats[internal.ToString(dialectStats[i])] = internal.ToInteger(dialectStats[i+1])
                }
        }

        ftInfo.DocTableSizeMB = internal.ToFloat(data["doc_table_size_mb"])

        if fieldStats, ok := data["field statistics"].([]interface{}); ok {
                for _, stat := range fieldStats {
                        if statMap, ok := stat.([]interface{}); ok {
                                ftInfo.FieldStatistics = append(ftInfo.FieldStatistics, FieldStatistic{
                                        Identifier: internal.ToString(statMap[1]),
                                        Attribute:  internal.ToString(statMap[3]),
                                        IndexErrors: IndexErrors{
                                                IndexingFailures:     internal.ToInteger(statMap[5].([]interface{})[1]),
                                                LastIndexingError:    internal.ToString(statMap[5].([]interface{})[3]),
                                                LastIndexingErrorKey: internal.ToString(statMap[5].([]interface{})[5]),
                                        },
                                })
                        }
                }
        }

        if gcStats, ok := data["gc_stats"].([]interface{}); ok {
                ftInfo.GCStats = GCStats{}
                for i := 0; i < len(gcStats); i += 2 {
                        if internal.ToLower(internal.ToString(gcStats[i])) == "bytes_collected" {
                                ftInfo.GCStats.BytesCollected = internal.ToInteger(gcStats[i+1])
                                continue
                        }
                        if internal.ToLower(internal.ToString(gcStats[i])) == "total_ms_run" {
                                ftInfo.GCStats.TotalMsRun = internal.ToInteger(gcStats[i+1])
                                continue
                        }
                        if internal.ToLower(internal.ToString(gcStats[i])) == "total_cycles" {
                                ftInfo.GCStats.TotalCycles = internal.ToInteger(gcStats[i+1])
                                continue
                        }
                        if internal.ToLower(internal.ToString(gcStats[i])) == "average_cycle_time_ms" {
                                ftInfo.GCStats.AverageCycleTimeMs = internal.ToString(gcStats[i+1])
                                continue
                        }
                        if internal.ToLower(internal.ToString(gcStats[i])) == "last_run_time_ms" {
                                ftInfo.GCStats.LastRunTimeMs = internal.ToInteger(gcStats[i+1])
                                continue
                        }
                        if internal.ToLower(internal.ToString(gcStats[i])) == "gc_numeric_trees_missed" {
                                ftInfo.GCStats.GCNumericTreesMissed = internal.ToInteger(gcStats[i+1])
                                continue
                        }
                        if internal.ToLower(internal.ToString(gcStats[i])) == "gc_blocks_denied" {
                                ftInfo.GCStats.GCBlocksDenied = internal.ToInteger(gcStats[i+1])
                                continue
                        }
                }
        }

        ftInfo.GeoshapesSzMB = internal.ToFloat(data["geoshapes_sz_mb"])
        ftInfo.HashIndexingFailures = internal.ToInteger(data["hash_indexing_failures"])

        if indexDef, ok := data["index_definition"].([]interface{}); ok {
                ftInfo.IndexDefinition = IndexDefinition{
                        KeyType:      internal.ToString(indexDef[1]),
                        Prefixes:     internal.ToStringSlice(indexDef[3]),
                        DefaultScore: internal.ToFloat(indexDef[5]),
                }
        }

        ftInfo.IndexName = internal.ToString(data["index_name"])
        ftInfo.IndexOptions = internal.ToStringSlice(data["index_options"].([]interface{}))
        ftInfo.Indexing = internal.ToInteger(data["indexing"])
        ftInfo.InvertedSzMB = internal.ToFloat(data["inverted_sz_mb"])
        ftInfo.KeyTableSizeMB = internal.ToFloat(data["key_table_size_mb"])
        ftInfo.MaxDocID = internal.ToInteger(data["max_doc_id"])
        ftInfo.NumDocs = internal.ToInteger(data["num_docs"])
        ftInfo.NumRecords = internal.ToInteger(data["num_records"])
        ftInfo.NumTerms = internal.ToInteger(data["num_terms"])
        ftInfo.NumberOfUses = internal.ToInteger(data["number_of_uses"])
        ftInfo.OffsetBitsPerRecordAvg = internal.ToString(data["offset_bits_per_record_avg"])
        ftInfo.OffsetVectorsSzMB = internal.ToFloat(data["offset_vectors_sz_mb"])
        ftInfo.OffsetsPerTermAvg = internal.ToString(data["offsets_per_term_avg"])
        ftInfo.PercentIndexed = internal.ToFloat(data["percent_indexed"])
        ftInfo.RecordsPerDocAvg = internal.ToString(data["records_per_doc_avg"])
        ftInfo.SortableValuesSizeMB = internal.ToFloat(data["sortable_values_size_mb"])
        ftInfo.TagOverheadSzMB = internal.ToFloat(data["tag_overhead_sz_mb"])
        ftInfo.TextOverheadSzMB = internal.ToFloat(data["text_overhead_sz_mb"])
        ftInfo.TotalIndexMemorySzMB = internal.ToFloat(data["total_index_memory_sz_mb"])
        ftInfo.TotalIndexingTime = internal.ToInteger(data["total_indexing_time"])
        ftInfo.TotalInvertedIndexBlocks = internal.ToInteger(data["total_inverted_index_blocks"])
        ftInfo.VectorIndexSzMB = internal.ToFloat(data["vector_index_sz_mb"])

        return ftInfo, nil
}

type FTInfoCmd struct {
        baseCmd
        val FTInfoResult
}

func newFTInfoCmd(ctx context.Context, args ...interface{}) *FTInfoCmd {
        return &FTInfoCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *FTInfoCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *FTInfoCmd) SetVal(val FTInfoResult) {
        cmd.val = val
}

func (cmd *FTInfoCmd) Result() (FTInfoResult, error) {
        return cmd.val, cmd.err
}

func (cmd *FTInfoCmd) Val() FTInfoResult {
        return cmd.val
}

func (cmd *FTInfoCmd) RawVal() interface{} {
        return cmd.rawVal
}

func (cmd *FTInfoCmd) RawResult() (interface{}, error) {
        return cmd.rawVal, cmd.err
}
func (cmd *FTInfoCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }

        data := make(map[string]interface{}, n)
        for i := 0; i < n; i++ {
                k, err := rd.ReadString()
                if err != nil {
                        return err
                }
                v, err := rd.ReadReply()
                if err != nil {
                        if err == Nil {
                                data[k] = Nil
                                continue
                        }
                        if err, ok := err.(proto.RedisError); ok {
                                data[k] = err
                                continue
                        }
                        return err
                }
                data[k] = v
        }
        cmd.val, err = parseFTInfo(data)
        if err != nil {
                return err
        }

        return nil
}

// FTInfo - Retrieves information about an index.
// The 'index' parameter specifies the index to retrieve information about.
// For more information, please refer to the Redis documentation:
// [FT.INFO]: (https://redis.io/commands/ft.info/)
func (c cmdable) FTInfo(ctx context.Context, index string) *FTInfoCmd {
        cmd := newFTInfoCmd(ctx, "FT.INFO", index)
        _ = c(ctx, cmd)
        return cmd
}

// FTSpellCheck - Checks a query string for spelling errors.
// For more details about spellcheck query please follow:
// https://redis.io/docs/interact/search-and-query/advanced-concepts/spellcheck/
// For more information, please refer to the Redis documentation:
// [FT.SPELLCHECK]: (https://redis.io/commands/ft.spellcheck/)
func (c cmdable) FTSpellCheck(ctx context.Context, index string, query string) *FTSpellCheckCmd {
        args := []interface{}{"FT.SPELLCHECK", index, query}
        cmd := newFTSpellCheckCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTSpellCheckWithArgs - Checks a query string for spelling errors with additional options.
// For more details about spellcheck query please follow:
// https://redis.io/docs/interact/search-and-query/advanced-concepts/spellcheck/
// For more information, please refer to the Redis documentation:
// [FT.SPELLCHECK]: (https://redis.io/commands/ft.spellcheck/)
func (c cmdable) FTSpellCheckWithArgs(ctx context.Context, index string, query string, options *FTSpellCheckOptions) *FTSpellCheckCmd {
        args := []interface{}{"FT.SPELLCHECK", index, query}
        if options != nil {
                if options.Distance > 0 {
                        args = append(args, "DISTANCE", options.Distance)
                }
                if options.Terms != nil {
                        args = append(args, "TERMS", options.Terms.Inclusion, options.Terms.Dictionary)
                        args = append(args, options.Terms.Terms...)
                }
                if options.Dialect > 0 {
                        args = append(args, "DIALECT", options.Dialect)
                } else {
                        args = append(args, "DIALECT", 2)
                }
        }
        cmd := newFTSpellCheckCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type FTSpellCheckCmd struct {
        baseCmd
        val []SpellCheckResult
}

func newFTSpellCheckCmd(ctx context.Context, args ...interface{}) *FTSpellCheckCmd {
        return &FTSpellCheckCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *FTSpellCheckCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *FTSpellCheckCmd) SetVal(val []SpellCheckResult) {
        cmd.val = val
}

func (cmd *FTSpellCheckCmd) Result() ([]SpellCheckResult, error) {
        return cmd.val, cmd.err
}

func (cmd *FTSpellCheckCmd) Val() []SpellCheckResult {
        return cmd.val
}

func (cmd *FTSpellCheckCmd) RawVal() interface{} {
        return cmd.rawVal
}

func (cmd *FTSpellCheckCmd) RawResult() (interface{}, error) {
        return cmd.rawVal, cmd.err
}

func (cmd *FTSpellCheckCmd) readReply(rd *proto.Reader) (err error) {
        data, err := rd.ReadSlice()
        if err != nil {
                return err
        }
        cmd.val, err = parseFTSpellCheck(data)
        if err != nil {
                return err
        }
        return nil
}

func parseFTSpellCheck(data []interface{}) ([]SpellCheckResult, error) {
        results := make([]SpellCheckResult, 0, len(data))

        for _, termData := range data {
                termInfo, ok := termData.([]interface{})
                if !ok || len(termInfo) != 3 {
                        return nil, fmt.Errorf("invalid term format")
                }

                term, ok := termInfo[1].(string)
                if !ok {
                        return nil, fmt.Errorf("invalid term format")
                }

                suggestionsData, ok := termInfo[2].([]interface{})
                if !ok {
                        return nil, fmt.Errorf("invalid suggestions format")
                }

                suggestions := make([]SpellCheckSuggestion, 0, len(suggestionsData))
                for _, suggestionData := range suggestionsData {
                        suggestionInfo, ok := suggestionData.([]interface{})
                        if !ok || len(suggestionInfo) != 2 {
                                return nil, fmt.Errorf("invalid suggestion format")
                        }

                        scoreStr, ok := suggestionInfo[0].(string)
                        if !ok {
                                return nil, fmt.Errorf("invalid suggestion score format")
                        }
                        score, err := strconv.ParseFloat(scoreStr, 64)
                        if err != nil {
                                return nil, fmt.Errorf("invalid suggestion score value")
                        }

                        suggestion, ok := suggestionInfo[1].(string)
                        if !ok {
                                return nil, fmt.Errorf("invalid suggestion format")
                        }

                        suggestions = append(suggestions, SpellCheckSuggestion{
                                Score:      score,
                                Suggestion: suggestion,
                        })
                }

                results = append(results, SpellCheckResult{
                        Term:        term,
                        Suggestions: suggestions,
                })
        }

        return results, nil
}

func parseFTSearch(data []interface{}, noContent, withScores, withPayloads, withSortKeys bool) (FTSearchResult, error) {
        if len(data) < 1 {
                return FTSearchResult{}, fmt.Errorf("unexpected search result format")
        }

        total, ok := data[0].(int64)
        if !ok {
                return FTSearchResult{}, fmt.Errorf("invalid total results format")
        }

        var results []Document
        for i := 1; i < len(data); {
                docID, ok := data[i].(string)
                if !ok {
                        return FTSearchResult{}, fmt.Errorf("invalid document ID format")
                }

                doc := Document{
                        ID:     docID,
                        Fields: make(map[string]string),
                }
                i++

                if noContent {
                        results = append(results, doc)
                        continue
                }

                if withScores && i < len(data) {
                        if scoreStr, ok := data[i].(string); ok {
                                score, err := strconv.ParseFloat(scoreStr, 64)
                                if err != nil {
                                        return FTSearchResult{}, fmt.Errorf("invalid score format")
                                }
                                doc.Score = &score
                                i++
                        }
                }

                if withPayloads && i < len(data) {
                        if payload, ok := data[i].(string); ok {
                                doc.Payload = &payload
                                i++
                        }
                }

                if withSortKeys && i < len(data) {
                        if sortKey, ok := data[i].(string); ok {
                                doc.SortKey = &sortKey
                                i++
                        }
                }

                if i < len(data) {
                        fields, ok := data[i].([]interface{})
                        if !ok {
                                return FTSearchResult{}, fmt.Errorf("invalid document fields format")
                        }

                        for j := 0; j < len(fields); j += 2 {
                                key, ok := fields[j].(string)
                                if !ok {
                                        return FTSearchResult{}, fmt.Errorf("invalid field key format")
                                }
                                value, ok := fields[j+1].(string)
                                if !ok {
                                        return FTSearchResult{}, fmt.Errorf("invalid field value format")
                                }
                                doc.Fields[key] = value
                        }
                        i++
                }

                results = append(results, doc)
        }
        return FTSearchResult{
                Total: int(total),
                Docs:  results,
        }, nil
}

type FTSearchCmd struct {
        baseCmd
        val     FTSearchResult
        options *FTSearchOptions
}

func newFTSearchCmd(ctx context.Context, options *FTSearchOptions, args ...interface{}) *FTSearchCmd {
        return &FTSearchCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
                options: options,
        }
}

func (cmd *FTSearchCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *FTSearchCmd) SetVal(val FTSearchResult) {
        cmd.val = val
}

func (cmd *FTSearchCmd) Result() (FTSearchResult, error) {
        return cmd.val, cmd.err
}

func (cmd *FTSearchCmd) Val() FTSearchResult {
        return cmd.val
}

func (cmd *FTSearchCmd) RawVal() interface{} {
        return cmd.rawVal
}

func (cmd *FTSearchCmd) RawResult() (interface{}, error) {
        return cmd.rawVal, cmd.err
}

func (cmd *FTSearchCmd) readReply(rd *proto.Reader) (err error) {
        data, err := rd.ReadSlice()
        if err != nil {
                return err
        }
        cmd.val, err = parseFTSearch(data, cmd.options.NoContent, cmd.options.WithScores, cmd.options.WithPayloads, cmd.options.WithSortKeys)
        if err != nil {
                return err
        }
        return nil
}

// FTSearch - Executes a search query on an index.
// The 'index' parameter specifies the index to search, and the 'query' parameter specifies the search query.
// For more information, please refer to the Redis documentation about [FT.SEARCH].
//
// [FT.SEARCH]: (https://redis.io/commands/ft.search/)
func (c cmdable) FTSearch(ctx context.Context, index string, query string) *FTSearchCmd {
        args := []interface{}{"FT.SEARCH", index, query}
        cmd := newFTSearchCmd(ctx, &FTSearchOptions{}, args...)
        _ = c(ctx, cmd)
        return cmd
}

type SearchQuery []interface{}

// FTSearchQuery - Executes a search query on an index with additional options.
// The 'index' parameter specifies the index to search, the 'query' parameter specifies the search query,
// and the 'options' parameter specifies additional options for the search.
// For more information, please refer to the Redis documentation about [FT.SEARCH].
//
// [FT.SEARCH]: (https://redis.io/commands/ft.search/)
func FTSearchQuery(query string, options *FTSearchOptions) SearchQuery {
        queryArgs := []interface{}{query}
        if options != nil {
                if options.NoContent {
                        queryArgs = append(queryArgs, "NOCONTENT")
                }
                if options.Verbatim {
                        queryArgs = append(queryArgs, "VERBATIM")
                }
                if options.NoStopWords {
                        queryArgs = append(queryArgs, "NOSTOPWORDS")
                }
                if options.WithScores {
                        queryArgs = append(queryArgs, "WITHSCORES")
                }
                if options.WithPayloads {
                        queryArgs = append(queryArgs, "WITHPAYLOADS")
                }
                if options.WithSortKeys {
                        queryArgs = append(queryArgs, "WITHSORTKEYS")
                }
                if options.Filters != nil {
                        for _, filter := range options.Filters {
                                queryArgs = append(queryArgs, "FILTER", filter.FieldName, filter.Min, filter.Max)
                        }
                }
                if options.GeoFilter != nil {
                        for _, geoFilter := range options.GeoFilter {
                                queryArgs = append(queryArgs, "GEOFILTER", geoFilter.FieldName, geoFilter.Longitude, geoFilter.Latitude, geoFilter.Radius, geoFilter.Unit)
                        }
                }
                if options.InKeys != nil {
                        queryArgs = append(queryArgs, "INKEYS", len(options.InKeys))
                        queryArgs = append(queryArgs, options.InKeys...)
                }
                if options.InFields != nil {
                        queryArgs = append(queryArgs, "INFIELDS", len(options.InFields))
                        queryArgs = append(queryArgs, options.InFields...)
                }
                if options.Return != nil {
                        queryArgs = append(queryArgs, "RETURN")
                        queryArgsReturn := []interface{}{}
                        for _, ret := range options.Return {
                                queryArgsReturn = append(queryArgsReturn, ret.FieldName)
                                if ret.As != "" {
                                        queryArgsReturn = append(queryArgsReturn, "AS", ret.As)
                                }
                        }
                        queryArgs = append(queryArgs, len(queryArgsReturn))
                        queryArgs = append(queryArgs, queryArgsReturn...)
                }
                if options.Slop > 0 {
                        queryArgs = append(queryArgs, "SLOP", options.Slop)
                }
                if options.Timeout > 0 {
                        queryArgs = append(queryArgs, "TIMEOUT", options.Timeout)
                }
                if options.InOrder {
                        queryArgs = append(queryArgs, "INORDER")
                }
                if options.Language != "" {
                        queryArgs = append(queryArgs, "LANGUAGE", options.Language)
                }
                if options.Expander != "" {
                        queryArgs = append(queryArgs, "EXPANDER", options.Expander)
                }
                if options.Scorer != "" {
                        queryArgs = append(queryArgs, "SCORER", options.Scorer)
                }
                if options.ExplainScore {
                        queryArgs = append(queryArgs, "EXPLAINSCORE")
                }
                if options.Payload != "" {
                        queryArgs = append(queryArgs, "PAYLOAD", options.Payload)
                }
                if options.SortBy != nil {
                        queryArgs = append(queryArgs, "SORTBY")
                        for _, sortBy := range options.SortBy {
                                queryArgs = append(queryArgs, sortBy.FieldName)
                                if sortBy.Asc && sortBy.Desc {
                                        panic("FT.SEARCH: ASC and DESC are mutually exclusive")
                                }
                                if sortBy.Asc {
                                        queryArgs = append(queryArgs, "ASC")
                                }
                                if sortBy.Desc {
                                        queryArgs = append(queryArgs, "DESC")
                                }
                        }
                        if options.SortByWithCount {
                                queryArgs = append(queryArgs, "WITHCOUNT")
                        }
                }
                if options.LimitOffset >= 0 && options.Limit > 0 {
                        queryArgs = append(queryArgs, "LIMIT", options.LimitOffset, options.Limit)
                }
                if options.Params != nil {
                        queryArgs = append(queryArgs, "PARAMS", len(options.Params)*2)
                        for key, value := range options.Params {
                                queryArgs = append(queryArgs, key, value)
                        }
                }
                if options.DialectVersion > 0 {
                        queryArgs = append(queryArgs, "DIALECT", options.DialectVersion)
                } else {
                        queryArgs = append(queryArgs, "DIALECT", 2)
                }
        }
        return queryArgs
}

// FTSearchWithArgs - Executes a search query on an index with additional options.
// The 'index' parameter specifies the index to search, the 'query' parameter specifies the search query,
// and the 'options' parameter specifies additional options for the search.
// For more information, please refer to the Redis documentation about [FT.SEARCH].
//
// [FT.SEARCH]: (https://redis.io/commands/ft.search/)
func (c cmdable) FTSearchWithArgs(ctx context.Context, index string, query string, options *FTSearchOptions) *FTSearchCmd {
        args := []interface{}{"FT.SEARCH", index, query}
        if options != nil {
                if options.NoContent {
                        args = append(args, "NOCONTENT")
                }
                if options.Verbatim {
                        args = append(args, "VERBATIM")
                }
                if options.NoStopWords {
                        args = append(args, "NOSTOPWORDS")
                }
                if options.WithScores {
                        args = append(args, "WITHSCORES")
                }
                if options.WithPayloads {
                        args = append(args, "WITHPAYLOADS")
                }
                if options.WithSortKeys {
                        args = append(args, "WITHSORTKEYS")
                }
                if options.Filters != nil {
                        for _, filter := range options.Filters {
                                args = append(args, "FILTER", filter.FieldName, filter.Min, filter.Max)
                        }
                }
                if options.GeoFilter != nil {
                        for _, geoFilter := range options.GeoFilter {
                                args = append(args, "GEOFILTER", geoFilter.FieldName, geoFilter.Longitude, geoFilter.Latitude, geoFilter.Radius, geoFilter.Unit)
                        }
                }
                if options.InKeys != nil {
                        args = append(args, "INKEYS", len(options.InKeys))
                        args = append(args, options.InKeys...)
                }
                if options.InFields != nil {
                        args = append(args, "INFIELDS", len(options.InFields))
                        args = append(args, options.InFields...)
                }
                if options.Return != nil {
                        args = append(args, "RETURN")
                        argsReturn := []interface{}{}
                        for _, ret := range options.Return {
                                argsReturn = append(argsReturn, ret.FieldName)
                                if ret.As != "" {
                                        argsReturn = append(argsReturn, "AS", ret.As)
                                }
                        }
                        args = append(args, len(argsReturn))
                        args = append(args, argsReturn...)
                }
                if options.Slop > 0 {
                        args = append(args, "SLOP", options.Slop)
                }
                if options.Timeout > 0 {
                        args = append(args, "TIMEOUT", options.Timeout)
                }
                if options.InOrder {
                        args = append(args, "INORDER")
                }
                if options.Language != "" {
                        args = append(args, "LANGUAGE", options.Language)
                }
                if options.Expander != "" {
                        args = append(args, "EXPANDER", options.Expander)
                }
                if options.Scorer != "" {
                        args = append(args, "SCORER", options.Scorer)
                }
                if options.ExplainScore {
                        args = append(args, "EXPLAINSCORE")
                }
                if options.Payload != "" {
                        args = append(args, "PAYLOAD", options.Payload)
                }
                if options.SortBy != nil {
                        args = append(args, "SORTBY")
                        for _, sortBy := range options.SortBy {
                                args = append(args, sortBy.FieldName)
                                if sortBy.Asc && sortBy.Desc {
                                        panic("FT.SEARCH: ASC and DESC are mutually exclusive")
                                }
                                if sortBy.Asc {
                                        args = append(args, "ASC")
                                }
                                if sortBy.Desc {
                                        args = append(args, "DESC")
                                }
                        }
                        if options.SortByWithCount {
                                args = append(args, "WITHCOUNT")
                        }
                }
                if options.CountOnly {
                        args = append(args, "LIMIT", 0, 0)
                } else {
                        if options.LimitOffset >= 0 && options.Limit > 0 || options.LimitOffset > 0 && options.Limit == 0 {
                                args = append(args, "LIMIT", options.LimitOffset, options.Limit)
                        }
                }
                if options.Params != nil {
                        args = append(args, "PARAMS", len(options.Params)*2)
                        for key, value := range options.Params {
                                args = append(args, key, value)
                        }
                }
                if options.DialectVersion > 0 {
                        args = append(args, "DIALECT", options.DialectVersion)
                } else {
                        args = append(args, "DIALECT", 2)
                }
        }
        cmd := newFTSearchCmd(ctx, options, args...)
        _ = c(ctx, cmd)
        return cmd
}

func NewFTSynDumpCmd(ctx context.Context, args ...interface{}) *FTSynDumpCmd {
        return &FTSynDumpCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *FTSynDumpCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *FTSynDumpCmd) SetVal(val []FTSynDumpResult) {
        cmd.val = val
}

func (cmd *FTSynDumpCmd) Val() []FTSynDumpResult {
        return cmd.val
}

func (cmd *FTSynDumpCmd) Result() ([]FTSynDumpResult, error) {
        return cmd.val, cmd.err
}

func (cmd *FTSynDumpCmd) RawVal() interface{} {
        return cmd.rawVal
}

func (cmd *FTSynDumpCmd) RawResult() (interface{}, error) {
        return cmd.rawVal, cmd.err
}

func (cmd *FTSynDumpCmd) readReply(rd *proto.Reader) error {
        termSynonymPairs, err := rd.ReadSlice()
        if err != nil {
                return err
        }

        var results []FTSynDumpResult
        for i := 0; i < len(termSynonymPairs); i += 2 {
                term, ok := termSynonymPairs[i].(string)
                if !ok {
                        return fmt.Errorf("invalid term format")
                }

                synonyms, ok := termSynonymPairs[i+1].([]interface{})
                if !ok {
                        return fmt.Errorf("invalid synonyms format")
                }

                synonymList := make([]string, len(synonyms))
                for j, syn := range synonyms {
                        synonym, ok := syn.(string)
                        if !ok {
                                return fmt.Errorf("invalid synonym format")
                        }
                        synonymList[j] = synonym
                }

                results = append(results, FTSynDumpResult{
                        Term:     term,
                        Synonyms: synonymList,
                })
        }

        cmd.val = results
        return nil
}

// FTSynDump - Dumps the contents of a synonym group.
// The 'index' parameter specifies the index to dump.
// For more information, please refer to the Redis documentation:
// [FT.SYNDUMP]: (https://redis.io/commands/ft.syndump/)
func (c cmdable) FTSynDump(ctx context.Context, index string) *FTSynDumpCmd {
        cmd := NewFTSynDumpCmd(ctx, "FT.SYNDUMP", index)
        _ = c(ctx, cmd)
        return cmd
}

// FTSynUpdate - Creates or updates a synonym group with additional terms.
// The 'index' parameter specifies the index to update, the 'synGroupId' parameter specifies the synonym group id, and the 'terms' parameter specifies the additional terms.
// For more information, please refer to the Redis documentation:
// [FT.SYNUPDATE]: (https://redis.io/commands/ft.synupdate/)
func (c cmdable) FTSynUpdate(ctx context.Context, index string, synGroupId interface{}, terms []interface{}) *StatusCmd {
        args := []interface{}{"FT.SYNUPDATE", index, synGroupId}
        args = append(args, terms...)
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTSynUpdateWithArgs - Creates or updates a synonym group with additional terms and options.
// The 'index' parameter specifies the index to update, the 'synGroupId' parameter specifies the synonym group id, the 'options' parameter specifies additional options for the update, and the 'terms' parameter specifies the additional terms.
// For more information, please refer to the Redis documentation:
// [FT.SYNUPDATE]: (https://redis.io/commands/ft.synupdate/)
func (c cmdable) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId interface{}, options *FTSynUpdateOptions, terms []interface{}) *StatusCmd {
        args := []interface{}{"FT.SYNUPDATE", index, synGroupId}
        if options.SkipInitialScan {
                args = append(args, "SKIPINITIALSCAN")
        }
        args = append(args, terms...)
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// FTTagVals - Returns all distinct values indexed in a tag field.
// The 'index' parameter specifies the index to check, and the 'field' parameter specifies the tag field to retrieve values from.
// For more information, please refer to the Redis documentation:
// [FT.TAGVALS]: (https://redis.io/commands/ft.tagvals/)
func (c cmdable) FTTagVals(ctx context.Context, index string, field string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "FT.TAGVALS", index, field)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "crypto/tls"
        "errors"
        "fmt"
        "net"
        "net/url"
        "strconv"
        "strings"
        "sync"
        "time"

        "github.com/redis/go-redis/v9/auth"
        "github.com/redis/go-redis/v9/internal"
        "github.com/redis/go-redis/v9/internal/pool"
        "github.com/redis/go-redis/v9/internal/rand"
        "github.com/redis/go-redis/v9/internal/util"
)

//------------------------------------------------------------------------------

// FailoverOptions are used to configure a failover client and should
// be passed to NewFailoverClient.
type FailoverOptions struct {
        // The master name.
        MasterName string
        // A seed list of host:port addresses of sentinel nodes.
        SentinelAddrs []string

        // ClientName will execute the `CLIENT SETNAME ClientName` command for each conn.
        ClientName string

        // If specified with SentinelPassword, enables ACL-based authentication (via
        // AUTH <user> <pass>).
        SentinelUsername string
        // Sentinel password from "requirepass <password>" (if enabled) in Sentinel
        // configuration, or, if SentinelUsername is also supplied, used for ACL-based
        // authentication.
        SentinelPassword string

        // Allows routing read-only commands to the closest master or replica node.
        // This option only works with NewFailoverClusterClient.
        RouteByLatency bool
        // Allows routing read-only commands to the random master or replica node.
        // This option only works with NewFailoverClusterClient.
        RouteRandomly bool

        // Route all commands to replica read-only nodes.
        ReplicaOnly bool

        // Use replicas disconnected with master when cannot get connected replicas
        // Now, this option only works in RandomReplicaAddr function.
        UseDisconnectedReplicas bool

        // Following options are copied from Options struct.

        Dialer    func(ctx context.Context, network, addr string) (net.Conn, error)
        OnConnect func(ctx context.Context, cn *Conn) error

        Protocol int
        Username string
        Password string
        // CredentialsProvider allows the username and password to be updated
        // before reconnecting. It should return the current username and password.
        CredentialsProvider func() (username string, password string)

        // CredentialsProviderContext is an enhanced parameter of CredentialsProvider,
        // done to maintain API compatibility. In the future,
        // there might be a merge between CredentialsProviderContext and CredentialsProvider.
        // There will be a conflict between them; if CredentialsProviderContext exists, we will ignore CredentialsProvider.
        CredentialsProviderContext func(ctx context.Context) (username string, password string, err error)

        // StreamingCredentialsProvider is used to retrieve the credentials
        // for the connection from an external source. Those credentials may change
        // during the connection lifetime. This is useful for managed identity
        // scenarios where the credentials are retrieved from an external source.
        //
        // Currently, this is a placeholder for the future implementation.
        StreamingCredentialsProvider auth.StreamingCredentialsProvider
        DB                           int

        MaxRetries      int
        MinRetryBackoff time.Duration
        MaxRetryBackoff time.Duration

        DialTimeout           time.Duration
        ReadTimeout           time.Duration
        WriteTimeout          time.Duration
        ContextTimeoutEnabled bool

        PoolFIFO bool

        PoolSize        int
        PoolTimeout     time.Duration
        MinIdleConns    int
        MaxIdleConns    int
        MaxActiveConns  int
        ConnMaxIdleTime time.Duration
        ConnMaxLifetime time.Duration

        TLSConfig *tls.Config

        // DisableIndentity - Disable set-lib on connect.
        //
        // default: false
        //
        // Deprecated: Use DisableIdentity instead.
        DisableIndentity bool

        // DisableIdentity is used to disable CLIENT SETINFO command on connect.
        //
        // default: false
        DisableIdentity bool

        IdentitySuffix string
        UnstableResp3  bool
}

func (opt *FailoverOptions) clientOptions() *Options {
        return &Options{
                Addr:       "FailoverClient",
                ClientName: opt.ClientName,

                Dialer:    opt.Dialer,
                OnConnect: opt.OnConnect,

                DB:                           opt.DB,
                Protocol:                     opt.Protocol,
                Username:                     opt.Username,
                Password:                     opt.Password,
                CredentialsProvider:          opt.CredentialsProvider,
                CredentialsProviderContext:   opt.CredentialsProviderContext,
                StreamingCredentialsProvider: opt.StreamingCredentialsProvider,

                MaxRetries:      opt.MaxRetries,
                MinRetryBackoff: opt.MinRetryBackoff,
                MaxRetryBackoff: opt.MaxRetryBackoff,

                DialTimeout:           opt.DialTimeout,
                ReadTimeout:           opt.ReadTimeout,
                WriteTimeout:          opt.WriteTimeout,
                ContextTimeoutEnabled: opt.ContextTimeoutEnabled,

                PoolFIFO:        opt.PoolFIFO,
                PoolSize:        opt.PoolSize,
                PoolTimeout:     opt.PoolTimeout,
                MinIdleConns:    opt.MinIdleConns,
                MaxIdleConns:    opt.MaxIdleConns,
                MaxActiveConns:  opt.MaxActiveConns,
                ConnMaxIdleTime: opt.ConnMaxIdleTime,
                ConnMaxLifetime: opt.ConnMaxLifetime,

                TLSConfig: opt.TLSConfig,

                DisableIdentity:  opt.DisableIdentity,
                DisableIndentity: opt.DisableIndentity,

                IdentitySuffix: opt.IdentitySuffix,
                UnstableResp3:  opt.UnstableResp3,
        }
}

func (opt *FailoverOptions) sentinelOptions(addr string) *Options {
        return &Options{
                Addr:       addr,
                ClientName: opt.ClientName,

                Dialer:    opt.Dialer,
                OnConnect: opt.OnConnect,

                DB:       0,
                Username: opt.SentinelUsername,
                Password: opt.SentinelPassword,

                MaxRetries:      opt.MaxRetries,
                MinRetryBackoff: opt.MinRetryBackoff,
                MaxRetryBackoff: opt.MaxRetryBackoff,

                DialTimeout:           opt.DialTimeout,
                ReadTimeout:           opt.ReadTimeout,
                WriteTimeout:          opt.WriteTimeout,
                ContextTimeoutEnabled: opt.ContextTimeoutEnabled,

                PoolFIFO:        opt.PoolFIFO,
                PoolSize:        opt.PoolSize,
                PoolTimeout:     opt.PoolTimeout,
                MinIdleConns:    opt.MinIdleConns,
                MaxIdleConns:    opt.MaxIdleConns,
                MaxActiveConns:  opt.MaxActiveConns,
                ConnMaxIdleTime: opt.ConnMaxIdleTime,
                ConnMaxLifetime: opt.ConnMaxLifetime,

                TLSConfig: opt.TLSConfig,

                DisableIdentity:  opt.DisableIdentity,
                DisableIndentity: opt.DisableIndentity,

                IdentitySuffix: opt.IdentitySuffix,
                UnstableResp3:  opt.UnstableResp3,
        }
}

func (opt *FailoverOptions) clusterOptions() *ClusterOptions {
        return &ClusterOptions{
                ClientName: opt.ClientName,

                Dialer:    opt.Dialer,
                OnConnect: opt.OnConnect,

                Protocol:                     opt.Protocol,
                Username:                     opt.Username,
                Password:                     opt.Password,
                CredentialsProvider:          opt.CredentialsProvider,
                CredentialsProviderContext:   opt.CredentialsProviderContext,
                StreamingCredentialsProvider: opt.StreamingCredentialsProvider,

                MaxRedirects: opt.MaxRetries,

                RouteByLatency: opt.RouteByLatency,
                RouteRandomly:  opt.RouteRandomly,

                MinRetryBackoff: opt.MinRetryBackoff,
                MaxRetryBackoff: opt.MaxRetryBackoff,

                DialTimeout:           opt.DialTimeout,
                ReadTimeout:           opt.ReadTimeout,
                WriteTimeout:          opt.WriteTimeout,
                ContextTimeoutEnabled: opt.ContextTimeoutEnabled,

                PoolFIFO:        opt.PoolFIFO,
                PoolSize:        opt.PoolSize,
                PoolTimeout:     opt.PoolTimeout,
                MinIdleConns:    opt.MinIdleConns,
                MaxIdleConns:    opt.MaxIdleConns,
                MaxActiveConns:  opt.MaxActiveConns,
                ConnMaxIdleTime: opt.ConnMaxIdleTime,
                ConnMaxLifetime: opt.ConnMaxLifetime,

                TLSConfig: opt.TLSConfig,

                DisableIdentity:  opt.DisableIdentity,
                DisableIndentity: opt.DisableIndentity,

                IdentitySuffix: opt.IdentitySuffix,
        }
}

// ParseFailoverURL parses a URL into FailoverOptions that can be used to connect to Redis.
// The URL must be in the form:
//
//        redis://<user>:<password>@<host>:<port>/<db_number>
//        or
//        rediss://<user>:<password>@<host>:<port>/<db_number>
//
// To add additional addresses, specify the query parameter, "addr" one or more times. e.g:
//
//        redis://<user>:<password>@<host>:<port>/<db_number>?addr=<host2>:<port2>&addr=<host3>:<port3>
//        or
//        rediss://<user>:<password>@<host>:<port>/<db_number>?addr=<host2>:<port2>&addr=<host3>:<port3>
//
// Most Option fields can be set using query parameters, with the following restrictions:
//   - field names are mapped using snake-case conversion: to set MaxRetries, use max_retries
//   - only scalar type fields are supported (bool, int, time.Duration)
//   - for time.Duration fields, values must be a valid input for time.ParseDuration();
//     additionally a plain integer as value (i.e. without unit) is interpreted as seconds
//   - to disable a duration field, use value less than or equal to 0; to use the default
//     value, leave the value blank or remove the parameter
//   - only the last value is interpreted if a parameter is given multiple times
//   - fields "network", "addr", "sentinel_username" and "sentinel_password" can only be set using other
//     URL attributes (scheme, host, userinfo, resp.), query parameters using these
//     names will be treated as unknown parameters
//   - unknown parameter names will result in an error
//   - use "skip_verify=true" to ignore TLS certificate validation
//
// Example:
//
//        redis://user:password@localhost:6789?master_name=mymaster&dial_timeout=3&read_timeout=6s&addr=localhost:6790&addr=localhost:6791
//        is equivalent to:
//        &FailoverOptions{
//                MasterName:  "mymaster",
//                Addr:        ["localhost:6789", "localhost:6790", "localhost:6791"]
//                DialTimeout: 3 * time.Second, // no time unit = seconds
//                ReadTimeout: 6 * time.Second,
//        }
func ParseFailoverURL(redisURL string) (*FailoverOptions, error) {
        u, err := url.Parse(redisURL)
        if err != nil {
                return nil, err
        }
        return setupFailoverConn(u)
}

func setupFailoverConn(u *url.URL) (*FailoverOptions, error) {
        o := &FailoverOptions{}

        o.SentinelUsername, o.SentinelPassword = getUserPassword(u)

        h, p := getHostPortWithDefaults(u)
        o.SentinelAddrs = append(o.SentinelAddrs, net.JoinHostPort(h, p))

        switch u.Scheme {
        case "rediss":
                o.TLSConfig = &tls.Config{ServerName: h, MinVersion: tls.VersionTLS12}
        case "redis":
                o.TLSConfig = nil
        default:
                return nil, fmt.Errorf("redis: invalid URL scheme: %s", u.Scheme)
        }

        f := strings.FieldsFunc(u.Path, func(r rune) bool {
                return r == '/'
        })
        switch len(f) {
        case 0:
                o.DB = 0
        case 1:
                var err error
                if o.DB, err = strconv.Atoi(f[0]); err != nil {
                        return nil, fmt.Errorf("redis: invalid database number: %q", f[0])
                }
        default:
                return nil, fmt.Errorf("redis: invalid URL path: %s", u.Path)
        }

        return setupFailoverConnParams(u, o)
}

func setupFailoverConnParams(u *url.URL, o *FailoverOptions) (*FailoverOptions, error) {
        q := queryOptions{q: u.Query()}

        o.MasterName = q.string("master_name")
        o.ClientName = q.string("client_name")
        o.RouteByLatency = q.bool("route_by_latency")
        o.RouteRandomly = q.bool("route_randomly")
        o.ReplicaOnly = q.bool("replica_only")
        o.UseDisconnectedReplicas = q.bool("use_disconnected_replicas")
        o.Protocol = q.int("protocol")
        o.Username = q.string("username")
        o.Password = q.string("password")
        o.MaxRetries = q.int("max_retries")
        o.MinRetryBackoff = q.duration("min_retry_backoff")
        o.MaxRetryBackoff = q.duration("max_retry_backoff")
        o.DialTimeout = q.duration("dial_timeout")
        o.ReadTimeout = q.duration("read_timeout")
        o.WriteTimeout = q.duration("write_timeout")
        o.ContextTimeoutEnabled = q.bool("context_timeout_enabled")
        o.PoolFIFO = q.bool("pool_fifo")
        o.PoolSize = q.int("pool_size")
        o.MinIdleConns = q.int("min_idle_conns")
        o.MaxIdleConns = q.int("max_idle_conns")
        o.MaxActiveConns = q.int("max_active_conns")
        o.ConnMaxLifetime = q.duration("conn_max_lifetime")
        o.ConnMaxIdleTime = q.duration("conn_max_idle_time")
        o.PoolTimeout = q.duration("pool_timeout")
        o.DisableIdentity = q.bool("disableIdentity")
        o.IdentitySuffix = q.string("identitySuffix")
        o.UnstableResp3 = q.bool("unstable_resp3")

        if q.err != nil {
                return nil, q.err
        }

        if tmp := q.string("db"); tmp != "" {
                db, err := strconv.Atoi(tmp)
                if err != nil {
                        return nil, fmt.Errorf("redis: invalid database number: %w", err)
                }
                o.DB = db
        }

        addrs := q.strings("addr")
        for _, addr := range addrs {
                h, p, err := net.SplitHostPort(addr)
                if err != nil || h == "" || p == "" {
                        return nil, fmt.Errorf("redis: unable to parse addr param: %s", addr)
                }

                o.SentinelAddrs = append(o.SentinelAddrs, net.JoinHostPort(h, p))
        }

        if o.TLSConfig != nil && q.has("skip_verify") {
                o.TLSConfig.InsecureSkipVerify = q.bool("skip_verify")
        }

        // any parameters left?
        if r := q.remaining(); len(r) > 0 {
                return nil, fmt.Errorf("redis: unexpected option: %s", strings.Join(r, ", "))
        }

        return o, nil
}

// NewFailoverClient returns a Redis client that uses Redis Sentinel
// for automatic failover. It's safe for concurrent use by multiple
// goroutines.
func NewFailoverClient(failoverOpt *FailoverOptions) *Client {
        if failoverOpt == nil {
                panic("redis: NewFailoverClient nil options")
        }

        if failoverOpt.RouteByLatency {
                panic("to route commands by latency, use NewFailoverClusterClient")
        }
        if failoverOpt.RouteRandomly {
                panic("to route commands randomly, use NewFailoverClusterClient")
        }

        sentinelAddrs := make([]string, len(failoverOpt.SentinelAddrs))
        copy(sentinelAddrs, failoverOpt.SentinelAddrs)

        rand.Shuffle(len(sentinelAddrs), func(i, j int) {
                sentinelAddrs[i], sentinelAddrs[j] = sentinelAddrs[j], sentinelAddrs[i]
        })

        failover := &sentinelFailover{
                opt:           failoverOpt,
                sentinelAddrs: sentinelAddrs,
        }

        opt := failoverOpt.clientOptions()
        opt.Dialer = masterReplicaDialer(failover)
        opt.init()

        var connPool *pool.ConnPool

        rdb := &Client{
                baseClient: &baseClient{
                        opt: opt,
                },
        }
        rdb.init()

        connPool = newConnPool(opt, rdb.dialHook)
        rdb.connPool = connPool
        rdb.onClose = rdb.wrappedOnClose(failover.Close)

        failover.mu.Lock()
        failover.onFailover = func(ctx context.Context, addr string) {
                _ = connPool.Filter(func(cn *pool.Conn) bool {
                        return cn.RemoteAddr().String() != addr
                })
        }
        failover.mu.Unlock()

        return rdb
}

func masterReplicaDialer(
        failover *sentinelFailover,
) func(ctx context.Context, network, addr string) (net.Conn, error) {
        return func(ctx context.Context, network, _ string) (net.Conn, error) {
                var addr string
                var err error

                if failover.opt.ReplicaOnly {
                        addr, err = failover.RandomReplicaAddr(ctx)
                } else {
                        addr, err = failover.MasterAddr(ctx)
                        if err == nil {
                                failover.trySwitchMaster(ctx, addr)
                        }
                }
                if err != nil {
                        return nil, err
                }
                if failover.opt.Dialer != nil {
                        return failover.opt.Dialer(ctx, network, addr)
                }

                netDialer := &net.Dialer{
                        Timeout:   failover.opt.DialTimeout,
                        KeepAlive: 5 * time.Minute,
                }
                if failover.opt.TLSConfig == nil {
                        return netDialer.DialContext(ctx, network, addr)
                }
                return tls.DialWithDialer(netDialer, network, addr, failover.opt.TLSConfig)
        }
}

//------------------------------------------------------------------------------

// SentinelClient is a client for a Redis Sentinel.
type SentinelClient struct {
        *baseClient
}

func NewSentinelClient(opt *Options) *SentinelClient {
        if opt == nil {
                panic("redis: NewSentinelClient nil options")
        }
        opt.init()
        c := &SentinelClient{
                baseClient: &baseClient{
                        opt: opt,
                },
        }

        c.initHooks(hooks{
                dial:    c.baseClient.dial,
                process: c.baseClient.process,
        })
        c.connPool = newConnPool(opt, c.dialHook)

        return c
}

func (c *SentinelClient) Process(ctx context.Context, cmd Cmder) error {
        err := c.processHook(ctx, cmd)
        cmd.SetErr(err)
        return err
}

func (c *SentinelClient) pubSub() *PubSub {
        pubsub := &PubSub{
                opt: c.opt,

                newConn: func(ctx context.Context, channels []string) (*pool.Conn, error) {
                        return c.newConn(ctx)
                },
                closeConn: c.connPool.CloseConn,
        }
        pubsub.init()
        return pubsub
}

// Ping is used to test if a connection is still alive, or to
// measure latency.
func (c *SentinelClient) Ping(ctx context.Context) *StringCmd {
        cmd := NewStringCmd(ctx, "ping")
        _ = c.Process(ctx, cmd)
        return cmd
}

// Subscribe subscribes the client to the specified channels.
// Channels can be omitted to create empty subscription.
func (c *SentinelClient) Subscribe(ctx context.Context, channels ...string) *PubSub {
        pubsub := c.pubSub()
        if len(channels) > 0 {
                _ = pubsub.Subscribe(ctx, channels...)
        }
        return pubsub
}

// PSubscribe subscribes the client to the given patterns.
// Patterns can be omitted to create empty subscription.
func (c *SentinelClient) PSubscribe(ctx context.Context, channels ...string) *PubSub {
        pubsub := c.pubSub()
        if len(channels) > 0 {
                _ = pubsub.PSubscribe(ctx, channels...)
        }
        return pubsub
}

func (c *SentinelClient) GetMasterAddrByName(ctx context.Context, name string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "sentinel", "get-master-addr-by-name", name)
        _ = c.Process(ctx, cmd)
        return cmd
}

func (c *SentinelClient) Sentinels(ctx context.Context, name string) *MapStringStringSliceCmd {
        cmd := NewMapStringStringSliceCmd(ctx, "sentinel", "sentinels", name)
        _ = c.Process(ctx, cmd)
        return cmd
}

// Failover forces a failover as if the master was not reachable, and without
// asking for agreement to other Sentinels.
func (c *SentinelClient) Failover(ctx context.Context, name string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "sentinel", "failover", name)
        _ = c.Process(ctx, cmd)
        return cmd
}

// Reset resets all the masters with matching name. The pattern argument is a
// glob-style pattern. The reset process clears any previous state in a master
// (including a failover in progress), and removes every replica and sentinel
// already discovered and associated with the master.
func (c *SentinelClient) Reset(ctx context.Context, pattern string) *IntCmd {
        cmd := NewIntCmd(ctx, "sentinel", "reset", pattern)
        _ = c.Process(ctx, cmd)
        return cmd
}

// FlushConfig forces Sentinel to rewrite its configuration on disk, including
// the current Sentinel state.
func (c *SentinelClient) FlushConfig(ctx context.Context) *StatusCmd {
        cmd := NewStatusCmd(ctx, "sentinel", "flushconfig")
        _ = c.Process(ctx, cmd)
        return cmd
}

// Master shows the state and info of the specified master.
func (c *SentinelClient) Master(ctx context.Context, name string) *MapStringStringCmd {
        cmd := NewMapStringStringCmd(ctx, "sentinel", "master", name)
        _ = c.Process(ctx, cmd)
        return cmd
}

// Masters shows a list of monitored masters and their state.
func (c *SentinelClient) Masters(ctx context.Context) *SliceCmd {
        cmd := NewSliceCmd(ctx, "sentinel", "masters")
        _ = c.Process(ctx, cmd)
        return cmd
}

// Replicas shows a list of replicas for the specified master and their state.
func (c *SentinelClient) Replicas(ctx context.Context, name string) *MapStringStringSliceCmd {
        cmd := NewMapStringStringSliceCmd(ctx, "sentinel", "replicas", name)
        _ = c.Process(ctx, cmd)
        return cmd
}

// CkQuorum checks if the current Sentinel configuration is able to reach the
// quorum needed to failover a master, and the majority needed to authorize the
// failover. This command should be used in monitoring systems to check if a
// Sentinel deployment is ok.
func (c *SentinelClient) CkQuorum(ctx context.Context, name string) *StringCmd {
        cmd := NewStringCmd(ctx, "sentinel", "ckquorum", name)
        _ = c.Process(ctx, cmd)
        return cmd
}

// Monitor tells the Sentinel to start monitoring a new master with the specified
// name, ip, port, and quorum.
func (c *SentinelClient) Monitor(ctx context.Context, name, ip, port, quorum string) *StringCmd {
        cmd := NewStringCmd(ctx, "sentinel", "monitor", name, ip, port, quorum)
        _ = c.Process(ctx, cmd)
        return cmd
}

// Set is used in order to change configuration parameters of a specific master.
func (c *SentinelClient) Set(ctx context.Context, name, option, value string) *StringCmd {
        cmd := NewStringCmd(ctx, "sentinel", "set", name, option, value)
        _ = c.Process(ctx, cmd)
        return cmd
}

// Remove is used in order to remove the specified master: the master will no
// longer be monitored, and will totally be removed from the internal state of
// the Sentinel.
func (c *SentinelClient) Remove(ctx context.Context, name string) *StringCmd {
        cmd := NewStringCmd(ctx, "sentinel", "remove", name)
        _ = c.Process(ctx, cmd)
        return cmd
}

//------------------------------------------------------------------------------

type sentinelFailover struct {
        opt *FailoverOptions

        sentinelAddrs []string

        onFailover func(ctx context.Context, addr string)
        onUpdate   func(ctx context.Context)

        mu          sync.RWMutex
        _masterAddr string
        sentinel    *SentinelClient
        pubsub      *PubSub
}

func (c *sentinelFailover) Close() error {
        c.mu.Lock()
        defer c.mu.Unlock()
        if c.sentinel != nil {
                return c.closeSentinel()
        }
        return nil
}

func (c *sentinelFailover) closeSentinel() error {
        firstErr := c.pubsub.Close()
        c.pubsub = nil

        err := c.sentinel.Close()
        if err != nil && firstErr == nil {
                firstErr = err
        }
        c.sentinel = nil

        return firstErr
}

func (c *sentinelFailover) RandomReplicaAddr(ctx context.Context) (string, error) {
        if c.opt == nil {
                return "", errors.New("opt is nil")
        }

        addresses, err := c.replicaAddrs(ctx, false)
        if err != nil {
                return "", err
        }

        if len(addresses) == 0 && c.opt.UseDisconnectedReplicas {
                addresses, err = c.replicaAddrs(ctx, true)
                if err != nil {
                        return "", err
                }
        }

        if len(addresses) == 0 {
                return c.MasterAddr(ctx)
        }
        return addresses[rand.Intn(len(addresses))], nil
}

func (c *sentinelFailover) MasterAddr(ctx context.Context) (string, error) {
        c.mu.RLock()
        sentinel := c.sentinel
        c.mu.RUnlock()

        if sentinel != nil {
                addr, err := c.getMasterAddr(ctx, sentinel)
                if err != nil {
                        if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
                                return "", err
                        }
                        // Continue on other errors
                        internal.Logger.Printf(ctx, "sentinel: GetMasterAddrByName name=%q failed: %s",
                                c.opt.MasterName, err)
                } else {
                        return addr, nil
                }
        }

        c.mu.Lock()
        defer c.mu.Unlock()

        if c.sentinel != nil {
                addr, err := c.getMasterAddr(ctx, c.sentinel)
                if err != nil {
                        _ = c.closeSentinel()
                        if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
                                return "", err
                        }
                        // Continue on other errors
                        internal.Logger.Printf(ctx, "sentinel: GetMasterAddrByName name=%q failed: %s",
                                c.opt.MasterName, err)
                } else {
                        return addr, nil
                }
        }

        var (
                masterAddr string
                wg         sync.WaitGroup
                once       sync.Once
                errCh      = make(chan error, len(c.sentinelAddrs))
        )

        ctx, cancel := context.WithCancel(ctx)
        defer cancel()

        for i, sentinelAddr := range c.sentinelAddrs {
                wg.Add(1)
                go func(i int, addr string) {
                        defer wg.Done()
                        sentinelCli := NewSentinelClient(c.opt.sentinelOptions(addr))
                        addrVal, err := sentinelCli.GetMasterAddrByName(ctx, c.opt.MasterName).Result()
                        if err != nil {
                                internal.Logger.Printf(ctx, "sentinel: GetMasterAddrByName addr=%s, master=%q failed: %s",
                                        addr, c.opt.MasterName, err)
                                _ = sentinelCli.Close()
                                errCh <- err
                                return
                        }
                        once.Do(func() {
                                masterAddr = net.JoinHostPort(addrVal[0], addrVal[1])
                                // Push working sentinel to the top
                                c.sentinelAddrs[0], c.sentinelAddrs[i] = c.sentinelAddrs[i], c.sentinelAddrs[0]
                                c.setSentinel(ctx, sentinelCli)
                                internal.Logger.Printf(ctx, "sentinel: selected addr=%s masterAddr=%s", addr, masterAddr)
                                cancel()
                        })
                }(i, sentinelAddr)
        }

        wg.Wait()
        close(errCh)
        if masterAddr != "" {
                return masterAddr, nil
        }
        errs := make([]error, 0, len(errCh))
        for err := range errCh {
                errs = append(errs, err)
        }
        return "", fmt.Errorf("redis: all sentinels specified in configuration are unreachable: %s", joinErrors(errs))
}

func joinErrors(errs []error) string {
        if len(errs) == 1 {
                return errs[0].Error()
        }

        b := []byte(errs[0].Error())
        for _, err := range errs[1:] {
                b = append(b, '\n')
                b = append(b, err.Error()...)
        }
        return util.BytesToString(b)
}

func (c *sentinelFailover) replicaAddrs(ctx context.Context, useDisconnected bool) ([]string, error) {
        c.mu.RLock()
        sentinel := c.sentinel
        c.mu.RUnlock()

        if sentinel != nil {
                addrs, err := c.getReplicaAddrs(ctx, sentinel)
                if err != nil {
                        if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
                                return nil, err
                        }
                        // Continue on other errors
                        internal.Logger.Printf(ctx, "sentinel: Replicas name=%q failed: %s",
                                c.opt.MasterName, err)
                } else if len(addrs) > 0 {
                        return addrs, nil
                }
        }

        c.mu.Lock()
        defer c.mu.Unlock()

        if c.sentinel != nil {
                addrs, err := c.getReplicaAddrs(ctx, c.sentinel)
                if err != nil {
                        _ = c.closeSentinel()
                        if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
                                return nil, err
                        }
                        // Continue on other errors
                        internal.Logger.Printf(ctx, "sentinel: Replicas name=%q failed: %s",
                                c.opt.MasterName, err)
                } else if len(addrs) > 0 {
                        return addrs, nil
                } else {
                        // No error and no replicas.
                        _ = c.closeSentinel()
                }
        }

        var sentinelReachable bool

        for i, sentinelAddr := range c.sentinelAddrs {
                sentinel := NewSentinelClient(c.opt.sentinelOptions(sentinelAddr))

                replicas, err := sentinel.Replicas(ctx, c.opt.MasterName).Result()
                if err != nil {
                        _ = sentinel.Close()
                        if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
                                return nil, err
                        }
                        internal.Logger.Printf(ctx, "sentinel: Replicas master=%q failed: %s",
                                c.opt.MasterName, err)
                        continue
                }
                sentinelReachable = true
                addrs := parseReplicaAddrs(replicas, useDisconnected)
                if len(addrs) == 0 {
                        continue
                }
                // Push working sentinel to the top.
                c.sentinelAddrs[0], c.sentinelAddrs[i] = c.sentinelAddrs[i], c.sentinelAddrs[0]
                c.setSentinel(ctx, sentinel)

                return addrs, nil
        }

        if sentinelReachable {
                return []string{}, nil
        }
        return []string{}, errors.New("redis: all sentinels specified in configuration are unreachable")
}

func (c *sentinelFailover) getMasterAddr(ctx context.Context, sentinel *SentinelClient) (string, error) {
        addr, err := sentinel.GetMasterAddrByName(ctx, c.opt.MasterName).Result()
        if err != nil {
                return "", err
        }
        return net.JoinHostPort(addr[0], addr[1]), nil
}

func (c *sentinelFailover) getReplicaAddrs(ctx context.Context, sentinel *SentinelClient) ([]string, error) {
        addrs, err := sentinel.Replicas(ctx, c.opt.MasterName).Result()
        if err != nil {
                internal.Logger.Printf(ctx, "sentinel: Replicas name=%q failed: %s",
                        c.opt.MasterName, err)
                return nil, err
        }
        return parseReplicaAddrs(addrs, false), nil
}

func parseReplicaAddrs(addrs []map[string]string, keepDisconnected bool) []string {
        nodes := make([]string, 0, len(addrs))
        for _, node := range addrs {
                isDown := false
                if flags, ok := node["flags"]; ok {
                        for _, flag := range strings.Split(flags, ",") {
                                switch flag {
                                case "s_down", "o_down":
                                        isDown = true
                                case "disconnected":
                                        if !keepDisconnected {
                                                isDown = true
                                        }
                                }
                        }
                }
                if !isDown && node["ip"] != "" && node["port"] != "" {
                        nodes = append(nodes, net.JoinHostPort(node["ip"], node["port"]))
                }
        }

        return nodes
}

func (c *sentinelFailover) trySwitchMaster(ctx context.Context, addr string) {
        c.mu.RLock()
        currentAddr := c._masterAddr //nolint:ifshort
        c.mu.RUnlock()

        if addr == currentAddr {
                return
        }

        c.mu.Lock()
        defer c.mu.Unlock()

        if addr == c._masterAddr {
                return
        }
        c._masterAddr = addr

        internal.Logger.Printf(ctx, "sentinel: new master=%q addr=%q",
                c.opt.MasterName, addr)
        if c.onFailover != nil {
                c.onFailover(ctx, addr)
        }
}

func (c *sentinelFailover) setSentinel(ctx context.Context, sentinel *SentinelClient) {
        if c.sentinel != nil {
                panic("not reached")
        }
        c.sentinel = sentinel
        c.discoverSentinels(ctx)

        c.pubsub = sentinel.Subscribe(ctx, "+switch-master", "+replica-reconf-done")
        go c.listen(c.pubsub)
}

func (c *sentinelFailover) discoverSentinels(ctx context.Context) {
        sentinels, err := c.sentinel.Sentinels(ctx, c.opt.MasterName).Result()
        if err != nil {
                internal.Logger.Printf(ctx, "sentinel: Sentinels master=%q failed: %s", c.opt.MasterName, err)
                return
        }
        for _, sentinel := range sentinels {
                ip, ok := sentinel["ip"]
                if !ok {
                        continue
                }
                port, ok := sentinel["port"]
                if !ok {
                        continue
                }
                if ip != "" && port != "" {
                        sentinelAddr := net.JoinHostPort(ip, port)
                        if !contains(c.sentinelAddrs, sentinelAddr) {
                                internal.Logger.Printf(ctx, "sentinel: discovered new sentinel=%q for master=%q",
                                        sentinelAddr, c.opt.MasterName)
                                c.sentinelAddrs = append(c.sentinelAddrs, sentinelAddr)
                        }
                }
        }
}

func (c *sentinelFailover) listen(pubsub *PubSub) {
        ctx := context.TODO()

        if c.onUpdate != nil {
                c.onUpdate(ctx)
        }

        ch := pubsub.Channel()
        for msg := range ch {
                if msg.Channel == "+switch-master" {
                        parts := strings.Split(msg.Payload, " ")
                        if parts[0] != c.opt.MasterName {
                                internal.Logger.Printf(pubsub.getContext(), "sentinel: ignore addr for master=%q", parts[0])
                                continue
                        }
                        addr := net.JoinHostPort(parts[3], parts[4])
                        c.trySwitchMaster(pubsub.getContext(), addr)
                }

                if c.onUpdate != nil {
                        c.onUpdate(ctx)
                }
        }
}

func contains(slice []string, str string) bool {
        for _, s := range slice {
                if s == str {
                        return true
                }
        }
        return false
}

//------------------------------------------------------------------------------

// NewFailoverClusterClient returns a client that supports routing read-only commands
// to a replica node.
func NewFailoverClusterClient(failoverOpt *FailoverOptions) *ClusterClient {
        if failoverOpt == nil {
                panic("redis: NewFailoverClusterClient nil options")
        }

        sentinelAddrs := make([]string, len(failoverOpt.SentinelAddrs))
        copy(sentinelAddrs, failoverOpt.SentinelAddrs)

        failover := &sentinelFailover{
                opt:           failoverOpt,
                sentinelAddrs: sentinelAddrs,
        }

        opt := failoverOpt.clusterOptions()
        if failoverOpt.DB != 0 {
                onConnect := opt.OnConnect

                opt.OnConnect = func(ctx context.Context, cn *Conn) error {
                        if err := cn.Select(ctx, failoverOpt.DB).Err(); err != nil {
                                return err
                        }

                        if onConnect != nil {
                                return onConnect(ctx, cn)
                        }

                        return nil
                }
        }

        opt.ClusterSlots = func(ctx context.Context) ([]ClusterSlot, error) {
                masterAddr, err := failover.MasterAddr(ctx)
                if err != nil {
                        return nil, err
                }

                nodes := []ClusterNode{{
                        Addr: masterAddr,
                }}

                replicaAddrs, err := failover.replicaAddrs(ctx, false)
                if err != nil {
                        return nil, err
                }

                for _, replicaAddr := range replicaAddrs {
                        nodes = append(nodes, ClusterNode{
                                Addr: replicaAddr,
                        })
                }

                slots := []ClusterSlot{
                        {
                                Start: 0,
                                End:   16383,
                                Nodes: nodes,
                        },
                }
                return slots, nil
        }

        c := NewClusterClient(opt)

        failover.mu.Lock()
        failover.onUpdate = func(ctx context.Context) {
                c.ReloadState(ctx)
        }
        failover.mu.Unlock()

        return c
}

package redis

import (
        "context"

        "github.com/redis/go-redis/v9/internal/hashtag"
)

type SetCmdable interface {
        SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd
        SCard(ctx context.Context, key string) *IntCmd
        SDiff(ctx context.Context, keys ...string) *StringSliceCmd
        SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd
        SInter(ctx context.Context, keys ...string) *StringSliceCmd
        SInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd
        SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd
        SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd
        SMIsMember(ctx context.Context, key string, members ...interface{}) *BoolSliceCmd
        SMembers(ctx context.Context, key string) *StringSliceCmd
        SMembersMap(ctx context.Context, key string) *StringStructMapCmd
        SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd
        SPop(ctx context.Context, key string) *StringCmd
        SPopN(ctx context.Context, key string, count int64) *StringSliceCmd
        SRandMember(ctx context.Context, key string) *StringCmd
        SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd
        SRem(ctx context.Context, key string, members ...interface{}) *IntCmd
        SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
        SUnion(ctx context.Context, keys ...string) *StringSliceCmd
        SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd
}

//------------------------------------------------------------------------------

func (c cmdable) SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(members))
        args[0] = "sadd"
        args[1] = key
        args = appendArgs(args, members)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SCard(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "scard", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SDiff(ctx context.Context, keys ...string) *StringSliceCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "sdiff"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {
        args := make([]interface{}, 2+len(keys))
        args[0] = "sdiffstore"
        args[1] = destination
        for i, key := range keys {
                args[2+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SInter(ctx context.Context, keys ...string) *StringSliceCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "sinter"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd {
        numKeys := len(keys)
        args := make([]interface{}, 4+numKeys)
        args[0] = "sintercard"
        args[1] = numKeys
        for i, key := range keys {
                args[2+i] = key
        }
        args[2+numKeys] = "limit"
        args[3+numKeys] = limit
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd {
        args := make([]interface{}, 2+len(keys))
        args[0] = "sinterstore"
        args[1] = destination
        for i, key := range keys {
                args[2+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd {
        cmd := NewBoolCmd(ctx, "sismember", key, member)
        _ = c(ctx, cmd)
        return cmd
}

// SMIsMember Redis `SMISMEMBER key member [member ...]` command.
func (c cmdable) SMIsMember(ctx context.Context, key string, members ...interface{}) *BoolSliceCmd {
        args := make([]interface{}, 2, 2+len(members))
        args[0] = "smismember"
        args[1] = key
        args = appendArgs(args, members)
        cmd := NewBoolSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// SMembers Redis `SMEMBERS key` command output as a slice.
func (c cmdable) SMembers(ctx context.Context, key string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "smembers", key)
        _ = c(ctx, cmd)
        return cmd
}

// SMembersMap Redis `SMEMBERS key` command output as a map.
func (c cmdable) SMembersMap(ctx context.Context, key string) *StringStructMapCmd {
        cmd := NewStringStructMapCmd(ctx, "smembers", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd {
        cmd := NewBoolCmd(ctx, "smove", source, destination, member)
        _ = c(ctx, cmd)
        return cmd
}

// SPop Redis `SPOP key` command.
func (c cmdable) SPop(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "spop", key)
        _ = c(ctx, cmd)
        return cmd
}

// SPopN Redis `SPOP key count` command.
func (c cmdable) SPopN(ctx context.Context, key string, count int64) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "spop", key, count)
        _ = c(ctx, cmd)
        return cmd
}

// SRandMember Redis `SRANDMEMBER key` command.
func (c cmdable) SRandMember(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "srandmember", key)
        _ = c(ctx, cmd)
        return cmd
}

// SRandMemberN Redis `SRANDMEMBER key count` command.
func (c cmdable) SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "srandmember", key, count)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SRem(ctx context.Context, key string, members ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(members))
        args[0] = "srem"
        args[1] = key
        args = appendArgs(args, members)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SUnion(ctx context.Context, keys ...string) *StringSliceCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "sunion"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd {
        args := make([]interface{}, 2+len(keys))
        args[0] = "sunionstore"
        args[1] = destination
        for i, key := range keys {
                args[2+i] = key
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
        args := []interface{}{"sscan", key, cursor}
        if match != "" {
                args = append(args, "match", match)
        }
        if count > 0 {
                args = append(args, "count", count)
        }
        cmd := NewScanCmd(ctx, c, args...)
        if hashtag.Present(match) {
                cmd.SetFirstKeyPos(4)
        }
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "strings"
        "time"

        "github.com/redis/go-redis/v9/internal/hashtag"
)

type SortedSetCmdable interface {
        BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
        BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
        BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd
        ZAdd(ctx context.Context, key string, members ...Z) *IntCmd
        ZAddLT(ctx context.Context, key string, members ...Z) *IntCmd
        ZAddGT(ctx context.Context, key string, members ...Z) *IntCmd
        ZAddNX(ctx context.Context, key string, members ...Z) *IntCmd
        ZAddXX(ctx context.Context, key string, members ...Z) *IntCmd
        ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd
        ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd
        ZCard(ctx context.Context, key string) *IntCmd
        ZCount(ctx context.Context, key, min, max string) *IntCmd
        ZLexCount(ctx context.Context, key, min, max string) *IntCmd
        ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd
        ZInter(ctx context.Context, store *ZStore) *StringSliceCmd
        ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd
        ZInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd
        ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd
        ZMPop(ctx context.Context, order string, count int64, keys ...string) *ZSliceWithKeyCmd
        ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd
        ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd
        ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd
        ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
        ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
        ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
        ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
        ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
        ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd
        ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd
        ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd
        ZRank(ctx context.Context, key, member string) *IntCmd
        ZRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd
        ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd
        ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd
        ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd
        ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd
        ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
        ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
        ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
        ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
        ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
        ZRevRank(ctx context.Context, key, member string) *IntCmd
        ZRevRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd
        ZScore(ctx context.Context, key, member string) *FloatCmd
        ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd
        ZRandMember(ctx context.Context, key string, count int) *StringSliceCmd
        ZRandMemberWithScores(ctx context.Context, key string, count int) *ZSliceCmd
        ZUnion(ctx context.Context, store ZStore) *StringSliceCmd
        ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd
        ZDiff(ctx context.Context, keys ...string) *StringSliceCmd
        ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd
        ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd
        ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
}

// BZPopMax Redis `BZPOPMAX key [key ...] timeout` command.
func (c cmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {
        args := make([]interface{}, 1+len(keys)+1)
        args[0] = "bzpopmax"
        for i, key := range keys {
                args[1+i] = key
        }
        args[len(args)-1] = formatSec(ctx, timeout)
        cmd := NewZWithKeyCmd(ctx, args...)
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

// BZPopMin Redis `BZPOPMIN key [key ...] timeout` command.
func (c cmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {
        args := make([]interface{}, 1+len(keys)+1)
        args[0] = "bzpopmin"
        for i, key := range keys {
                args[1+i] = key
        }
        args[len(args)-1] = formatSec(ctx, timeout)
        cmd := NewZWithKeyCmd(ctx, args...)
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

// BZMPop is the blocking variant of ZMPOP.
// When any of the sorted sets contains elements, this command behaves exactly like ZMPOP.
// When all sorted sets are empty, Redis will block the connection until another client adds members to one of the keys or until the timeout elapses.
// A timeout of zero can be used to block indefinitely.
// example: client.BZMPop(ctx, 0,"max", 1, "set")
func (c cmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd {
        args := make([]interface{}, 3+len(keys), 6+len(keys))
        args[0] = "bzmpop"
        args[1] = formatSec(ctx, timeout)
        args[2] = len(keys)
        for i, key := range keys {
                args[3+i] = key
        }
        args = append(args, strings.ToLower(order), "count", count)
        cmd := NewZSliceWithKeyCmd(ctx, args...)
        cmd.setReadTimeout(timeout)
        _ = c(ctx, cmd)
        return cmd
}

// ZAddArgs WARN: The GT, LT and NX options are mutually exclusive.
type ZAddArgs struct {
        NX      bool
        XX      bool
        LT      bool
        GT      bool
        Ch      bool
        Members []Z
}

func (c cmdable) zAddArgs(key string, args ZAddArgs, incr bool) []interface{} {
        a := make([]interface{}, 0, 6+2*len(args.Members))
        a = append(a, "zadd", key)

        // The GT, LT and NX options are mutually exclusive.
        if args.NX {
                a = append(a, "nx")
        } else {
                if args.XX {
                        a = append(a, "xx")
                }
                if args.GT {
                        a = append(a, "gt")
                } else if args.LT {
                        a = append(a, "lt")
                }
        }
        if args.Ch {
                a = append(a, "ch")
        }
        if incr {
                a = append(a, "incr")
        }
        for _, m := range args.Members {
                a = append(a, m.Score)
                a = append(a, m.Member)
        }
        return a
}

func (c cmdable) ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd {
        cmd := NewIntCmd(ctx, c.zAddArgs(key, args, false)...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd {
        cmd := NewFloatCmd(ctx, c.zAddArgs(key, args, true)...)
        _ = c(ctx, cmd)
        return cmd
}

// ZAdd Redis `ZADD key score member [score member ...]` command.
func (c cmdable) ZAdd(ctx context.Context, key string, members ...Z) *IntCmd {
        return c.ZAddArgs(ctx, key, ZAddArgs{
                Members: members,
        })
}

// ZAddLT Redis `ZADD key LT score member [score member ...]` command.
func (c cmdable) ZAddLT(ctx context.Context, key string, members ...Z) *IntCmd {
        return c.ZAddArgs(ctx, key, ZAddArgs{
                LT:      true,
                Members: members,
        })
}

// ZAddGT Redis `ZADD key GT score member [score member ...]` command.
func (c cmdable) ZAddGT(ctx context.Context, key string, members ...Z) *IntCmd {
        return c.ZAddArgs(ctx, key, ZAddArgs{
                GT:      true,
                Members: members,
        })
}

// ZAddNX Redis `ZADD key NX score member [score member ...]` command.
func (c cmdable) ZAddNX(ctx context.Context, key string, members ...Z) *IntCmd {
        return c.ZAddArgs(ctx, key, ZAddArgs{
                NX:      true,
                Members: members,
        })
}

// ZAddXX Redis `ZADD key XX score member [score member ...]` command.
func (c cmdable) ZAddXX(ctx context.Context, key string, members ...Z) *IntCmd {
        return c.ZAddArgs(ctx, key, ZAddArgs{
                XX:      true,
                Members: members,
        })
}

func (c cmdable) ZCard(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "zcard", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZCount(ctx context.Context, key, min, max string) *IntCmd {
        cmd := NewIntCmd(ctx, "zcount", key, min, max)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZLexCount(ctx context.Context, key, min, max string) *IntCmd {
        cmd := NewIntCmd(ctx, "zlexcount", key, min, max)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd {
        cmd := NewFloatCmd(ctx, "zincrby", key, increment, member)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd {
        args := make([]interface{}, 0, 3+store.len())
        args = append(args, "zinterstore", destination, len(store.Keys))
        args = store.appendArgs(args)
        cmd := NewIntCmd(ctx, args...)
        cmd.SetFirstKeyPos(3)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZInter(ctx context.Context, store *ZStore) *StringSliceCmd {
        args := make([]interface{}, 0, 2+store.len())
        args = append(args, "zinter", len(store.Keys))
        args = store.appendArgs(args)
        cmd := NewStringSliceCmd(ctx, args...)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd {
        args := make([]interface{}, 0, 3+store.len())
        args = append(args, "zinter", len(store.Keys))
        args = store.appendArgs(args)
        args = append(args, "withscores")
        cmd := NewZSliceCmd(ctx, args...)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd {
        numKeys := len(keys)
        args := make([]interface{}, 4+numKeys)
        args[0] = "zintercard"
        args[1] = numKeys
        for i, key := range keys {
                args[2+i] = key
        }
        args[2+numKeys] = "limit"
        args[3+numKeys] = limit
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// ZMPop Pops one or more elements with the highest or lowest score from the first non-empty sorted set key from the list of provided key names.
// direction: "max" (highest score) or "min" (lowest score), count: > 0
// example: client.ZMPop(ctx, "max", 5, "set1", "set2")
func (c cmdable) ZMPop(ctx context.Context, order string, count int64, keys ...string) *ZSliceWithKeyCmd {
        args := make([]interface{}, 2+len(keys), 5+len(keys))
        args[0] = "zmpop"
        args[1] = len(keys)
        for i, key := range keys {
                args[2+i] = key
        }
        args = append(args, strings.ToLower(order), "count", count)
        cmd := NewZSliceWithKeyCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd {
        args := make([]interface{}, 2+len(members))
        args[0] = "zmscore"
        args[1] = key
        for i, member := range members {
                args[2+i] = member
        }
        cmd := NewFloatSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd {
        args := []interface{}{
                "zpopmax",
                key,
        }

        switch len(count) {
        case 0:
                break
        case 1:
                args = append(args, count[0])
        default:
                panic("too many arguments")
        }

        cmd := NewZSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd {
        args := []interface{}{
                "zpopmin",
                key,
        }

        switch len(count) {
        case 0:
                break
        case 1:
                args = append(args, count[0])
        default:
                panic("too many arguments")
        }

        cmd := NewZSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// ZRangeArgs is all the options of the ZRange command.
// In version> 6.2.0, you can replace the(cmd):
//
//        ZREVRANGE,
//        ZRANGEBYSCORE,
//        ZREVRANGEBYSCORE,
//        ZRANGEBYLEX,
//        ZREVRANGEBYLEX.
//
// Please pay attention to your redis-server version.
//
// Rev, ByScore, ByLex and Offset+Count options require redis-server 6.2.0 and higher.
type ZRangeArgs struct {
        Key string

        // When the ByScore option is provided, the open interval(exclusive) can be set.
        // By default, the score intervals specified by <Start> and <Stop> are closed (inclusive).
        // It is similar to the deprecated(6.2.0+) ZRangeByScore command.
        // For example:
        //                ZRangeArgs{
        //                        Key:                                 "example-key",
        //                         Start:                                 "(3",
        //                         Stop:                                 8,
        //                        ByScore:                        true,
        //                 }
        //                  cmd: "ZRange example-key (3 8 ByScore"  (3 < score <= 8).
        //
        // For the ByLex option, it is similar to the deprecated(6.2.0+) ZRangeByLex command.
        // You can set the <Start> and <Stop> options as follows:
        //                ZRangeArgs{
        //                        Key:                                 "example-key",
        //                         Start:                                 "[abc",
        //                         Stop:                                 "(def",
        //                        ByLex:                                true,
        //                 }
        //                cmd: "ZRange example-key [abc (def ByLex"
        //
        // For normal cases (ByScore==false && ByLex==false), <Start> and <Stop> should be set to the index range (int).
        // You can read the documentation for more information: https://redis.io/commands/zrange
        Start interface{}
        Stop  interface{}

        // The ByScore and ByLex options are mutually exclusive.
        ByScore bool
        ByLex   bool

        Rev bool

        // limit offset count.
        Offset int64
        Count  int64
}

func (z ZRangeArgs) appendArgs(args []interface{}) []interface{} {
        // For Rev+ByScore/ByLex, we need to adjust the position of <Start> and <Stop>.
        if z.Rev && (z.ByScore || z.ByLex) {
                args = append(args, z.Key, z.Stop, z.Start)
        } else {
                args = append(args, z.Key, z.Start, z.Stop)
        }

        if z.ByScore {
                args = append(args, "byscore")
        } else if z.ByLex {
                args = append(args, "bylex")
        }
        if z.Rev {
                args = append(args, "rev")
        }
        if z.Offset != 0 || z.Count != 0 {
                args = append(args, "limit", z.Offset, z.Count)
        }
        return args
}

func (c cmdable) ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd {
        args := make([]interface{}, 0, 9)
        args = append(args, "zrange")
        args = z.appendArgs(args)
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd {
        args := make([]interface{}, 0, 10)
        args = append(args, "zrange")
        args = z.appendArgs(args)
        args = append(args, "withscores")
        cmd := NewZSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
        return c.ZRangeArgs(ctx, ZRangeArgs{
                Key:   key,
                Start: start,
                Stop:  stop,
        })
}

func (c cmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {
        return c.ZRangeArgsWithScores(ctx, ZRangeArgs{
                Key:   key,
                Start: start,
                Stop:  stop,
        })
}

type ZRangeBy struct {
        Min, Max      string
        Offset, Count int64
}

func (c cmdable) zRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy, withScores bool) *StringSliceCmd {
        args := []interface{}{zcmd, key, opt.Min, opt.Max}
        if withScores {
                args = append(args, "withscores")
        }
        if opt.Offset != 0 || opt.Count != 0 {
                args = append(
                        args,
                        "limit",
                        opt.Offset,
                        opt.Count,
                )
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
        return c.zRangeBy(ctx, "zrangebyscore", key, opt, false)
}

func (c cmdable) ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
        return c.zRangeBy(ctx, "zrangebylex", key, opt, false)
}

func (c cmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {
        args := []interface{}{"zrangebyscore", key, opt.Min, opt.Max, "withscores"}
        if opt.Offset != 0 || opt.Count != 0 {
                args = append(
                        args,
                        "limit",
                        opt.Offset,
                        opt.Count,
                )
        }
        cmd := NewZSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd {
        args := make([]interface{}, 0, 10)
        args = append(args, "zrangestore", dst)
        args = z.appendArgs(args)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRank(ctx context.Context, key, member string) *IntCmd {
        cmd := NewIntCmd(ctx, "zrank", key, member)
        _ = c(ctx, cmd)
        return cmd
}

// ZRankWithScore according to the Redis documentation, if member does not exist
// in the sorted set or key does not exist, it will return a redis.Nil error.
func (c cmdable) ZRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd {
        cmd := NewRankWithScoreCmd(ctx, "zrank", key, member, "withscore")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd {
        args := make([]interface{}, 2, 2+len(members))
        args[0] = "zrem"
        args[1] = key
        args = appendArgs(args, members)
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd {
        cmd := NewIntCmd(
                ctx,
                "zremrangebyrank",
                key,
                start,
                stop,
        )
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd {
        cmd := NewIntCmd(ctx, "zremrangebyscore", key, min, max)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd {
        cmd := NewIntCmd(ctx, "zremrangebylex", key, min, max)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "zrevrange", key, start, stop)
        _ = c(ctx, cmd)
        return cmd
}

// ZRevRangeWithScores according to the Redis documentation, if member does not exist
// in the sorted set or key does not exist, it will return a redis.Nil error.
func (c cmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {
        cmd := NewZSliceCmd(ctx, "zrevrange", key, start, stop, "withscores")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) zRevRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy) *StringSliceCmd {
        args := []interface{}{zcmd, key, opt.Max, opt.Min}
        if opt.Offset != 0 || opt.Count != 0 {
                args = append(
                        args,
                        "limit",
                        opt.Offset,
                        opt.Count,
                )
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
        return c.zRevRangeBy(ctx, "zrevrangebyscore", key, opt)
}

func (c cmdable) ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
        return c.zRevRangeBy(ctx, "zrevrangebylex", key, opt)
}

func (c cmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {
        args := []interface{}{"zrevrangebyscore", key, opt.Max, opt.Min, "withscores"}
        if opt.Offset != 0 || opt.Count != 0 {
                args = append(
                        args,
                        "limit",
                        opt.Offset,
                        opt.Count,
                )
        }
        cmd := NewZSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRevRank(ctx context.Context, key, member string) *IntCmd {
        cmd := NewIntCmd(ctx, "zrevrank", key, member)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZRevRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd {
        cmd := NewRankWithScoreCmd(ctx, "zrevrank", key, member, "withscore")
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZScore(ctx context.Context, key, member string) *FloatCmd {
        cmd := NewFloatCmd(ctx, "zscore", key, member)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZUnion(ctx context.Context, store ZStore) *StringSliceCmd {
        args := make([]interface{}, 0, 2+store.len())
        args = append(args, "zunion", len(store.Keys))
        args = store.appendArgs(args)
        cmd := NewStringSliceCmd(ctx, args...)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd {
        args := make([]interface{}, 0, 3+store.len())
        args = append(args, "zunion", len(store.Keys))
        args = store.appendArgs(args)
        args = append(args, "withscores")
        cmd := NewZSliceCmd(ctx, args...)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd {
        args := make([]interface{}, 0, 3+store.len())
        args = append(args, "zunionstore", dest, len(store.Keys))
        args = store.appendArgs(args)
        cmd := NewIntCmd(ctx, args...)
        cmd.SetFirstKeyPos(3)
        _ = c(ctx, cmd)
        return cmd
}

// ZRandMember redis-server version >= 6.2.0.
func (c cmdable) ZRandMember(ctx context.Context, key string, count int) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "zrandmember", key, count)
        _ = c(ctx, cmd)
        return cmd
}

// ZRandMemberWithScores redis-server version >= 6.2.0.
func (c cmdable) ZRandMemberWithScores(ctx context.Context, key string, count int) *ZSliceCmd {
        cmd := NewZSliceCmd(ctx, "zrandmember", key, count, "withscores")
        _ = c(ctx, cmd)
        return cmd
}

// ZDiff redis-server version >= 6.2.0.
func (c cmdable) ZDiff(ctx context.Context, keys ...string) *StringSliceCmd {
        args := make([]interface{}, 2+len(keys))
        args[0] = "zdiff"
        args[1] = len(keys)
        for i, key := range keys {
                args[i+2] = key
        }

        cmd := NewStringSliceCmd(ctx, args...)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

// ZDiffWithScores redis-server version >= 6.2.0.
func (c cmdable) ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd {
        args := make([]interface{}, 3+len(keys))
        args[0] = "zdiff"
        args[1] = len(keys)
        for i, key := range keys {
                args[i+2] = key
        }
        args[len(keys)+2] = "withscores"

        cmd := NewZSliceCmd(ctx, args...)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

// ZDiffStore redis-server version >=6.2.0.
func (c cmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {
        args := make([]interface{}, 0, 3+len(keys))
        args = append(args, "zdiffstore", destination, len(keys))
        for _, key := range keys {
                args = append(args, key)
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
        args := []interface{}{"zscan", key, cursor}
        if match != "" {
                args = append(args, "match", match)
        }
        if count > 0 {
                args = append(args, "count", count)
        }
        cmd := NewScanCmd(ctx, c, args...)
        if hashtag.Present(match) {
                cmd.SetFirstKeyPos(4)
        }
        _ = c(ctx, cmd)
        return cmd
}

// Z represents sorted set member.
type Z struct {
        Score  float64
        Member interface{}
}

// ZWithKey represents sorted set member including the name of the key where it was popped.
type ZWithKey struct {
        Z
        Key string
}

// ZStore is used as an arg to ZInter/ZInterStore and ZUnion/ZUnionStore.
type ZStore struct {
        Keys    []string
        Weights []float64
        // Can be SUM, MIN or MAX.
        Aggregate string
}

func (z ZStore) len() (n int) {
        n = len(z.Keys)
        if len(z.Weights) > 0 {
                n += 1 + len(z.Weights)
        }
        if z.Aggregate != "" {
                n += 2
        }
        return n
}

func (z ZStore) appendArgs(args []interface{}) []interface{} {
        for _, key := range z.Keys {
                args = append(args, key)
        }
        if len(z.Weights) > 0 {
                args = append(args, "weights")
                for _, weights := range z.Weights {
                        args = append(args, weights)
                }
        }
        if z.Aggregate != "" {
                args = append(args, "aggregate", z.Aggregate)
        }
        return args
}

package redis

import (
        "context"
        "time"
)

type StreamCmdable interface {
        XAdd(ctx context.Context, a *XAddArgs) *StringCmd
        XDel(ctx context.Context, stream string, ids ...string) *IntCmd
        XLen(ctx context.Context, stream string) *IntCmd
        XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd
        XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd
        XRevRange(ctx context.Context, stream string, start, stop string) *XMessageSliceCmd
        XRevRangeN(ctx context.Context, stream string, start, stop string, count int64) *XMessageSliceCmd
        XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd
        XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd
        XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd
        XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd
        XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd
        XGroupDestroy(ctx context.Context, stream, group string) *IntCmd
        XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *IntCmd
        XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd
        XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd
        XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd
        XPending(ctx context.Context, stream, group string) *XPendingCmd
        XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd
        XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd
        XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd
        XAutoClaim(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimCmd
        XAutoClaimJustID(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimJustIDCmd
        XTrimMaxLen(ctx context.Context, key string, maxLen int64) *IntCmd
        XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *IntCmd
        XTrimMinID(ctx context.Context, key string, minID string) *IntCmd
        XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *IntCmd
        XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd
        XInfoStream(ctx context.Context, key string) *XInfoStreamCmd
        XInfoStreamFull(ctx context.Context, key string, count int) *XInfoStreamFullCmd
        XInfoConsumers(ctx context.Context, key string, group string) *XInfoConsumersCmd
}

// XAddArgs accepts values in the following formats:
//   - XAddArgs.Values = []interface{}{"key1", "value1", "key2", "value2"}
//   - XAddArgs.Values = []string("key1", "value1", "key2", "value2")
//   - XAddArgs.Values = map[string]interface{}{"key1": "value1", "key2": "value2"}
//
// Note that map will not preserve the order of key-value pairs.
// MaxLen/MaxLenApprox and MinID are in conflict, only one of them can be used.
type XAddArgs struct {
        Stream     string
        NoMkStream bool
        MaxLen     int64 // MAXLEN N
        MinID      string
        // Approx causes MaxLen and MinID to use "~" matcher (instead of "=").
        Approx bool
        Limit  int64
        ID     string
        Values interface{}
}

func (c cmdable) XAdd(ctx context.Context, a *XAddArgs) *StringCmd {
        args := make([]interface{}, 0, 11)
        args = append(args, "xadd", a.Stream)
        if a.NoMkStream {
                args = append(args, "nomkstream")
        }
        switch {
        case a.MaxLen > 0:
                if a.Approx {
                        args = append(args, "maxlen", "~", a.MaxLen)
                } else {
                        args = append(args, "maxlen", a.MaxLen)
                }
        case a.MinID != "":
                if a.Approx {
                        args = append(args, "minid", "~", a.MinID)
                } else {
                        args = append(args, "minid", a.MinID)
                }
        }
        if a.Limit > 0 {
                args = append(args, "limit", a.Limit)
        }
        if a.ID != "" {
                args = append(args, a.ID)
        } else {
                args = append(args, "*")
        }
        args = appendArg(args, a.Values)

        cmd := NewStringCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XDel(ctx context.Context, stream string, ids ...string) *IntCmd {
        args := []interface{}{"xdel", stream}
        for _, id := range ids {
                args = append(args, id)
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XLen(ctx context.Context, stream string) *IntCmd {
        cmd := NewIntCmd(ctx, "xlen", stream)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {
        cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {
        cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop, "count", count)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XRevRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {
        cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {
        cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop, "count", count)
        _ = c(ctx, cmd)
        return cmd
}

type XReadArgs struct {
        Streams []string // list of streams and ids, e.g. stream1 stream2 id1 id2
        Count   int64
        Block   time.Duration
        ID      string
}

func (c cmdable) XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd {
        args := make([]interface{}, 0, 2*len(a.Streams)+6)
        args = append(args, "xread")

        keyPos := int8(1)
        if a.Count > 0 {
                args = append(args, "count")
                args = append(args, a.Count)
                keyPos += 2
        }
        if a.Block >= 0 {
                args = append(args, "block")
                args = append(args, int64(a.Block/time.Millisecond))
                keyPos += 2
        }
        args = append(args, "streams")
        keyPos++
        for _, s := range a.Streams {
                args = append(args, s)
        }
        if a.ID != "" {
                for range a.Streams {
                        args = append(args, a.ID)
                }
        }

        cmd := NewXStreamSliceCmd(ctx, args...)
        if a.Block >= 0 {
                cmd.setReadTimeout(a.Block)
        }
        cmd.SetFirstKeyPos(keyPos)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd {
        return c.XRead(ctx, &XReadArgs{
                Streams: streams,
                Block:   -1,
        })
}

func (c cmdable) XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start, "mkstream")
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd {
        cmd := NewStatusCmd(ctx, "xgroup", "setid", stream, group, start)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XGroupDestroy(ctx context.Context, stream, group string) *IntCmd {
        cmd := NewIntCmd(ctx, "xgroup", "destroy", stream, group)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {
        cmd := NewIntCmd(ctx, "xgroup", "createconsumer", stream, group, consumer)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {
        cmd := NewIntCmd(ctx, "xgroup", "delconsumer", stream, group, consumer)
        cmd.SetFirstKeyPos(2)
        _ = c(ctx, cmd)
        return cmd
}

type XReadGroupArgs struct {
        Group    string
        Consumer string
        Streams  []string // list of streams and ids, e.g. stream1 stream2 id1 id2
        Count    int64
        Block    time.Duration
        NoAck    bool
}

func (c cmdable) XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd {
        args := make([]interface{}, 0, 10+len(a.Streams))
        args = append(args, "xreadgroup", "group", a.Group, a.Consumer)

        keyPos := int8(4)
        if a.Count > 0 {
                args = append(args, "count", a.Count)
                keyPos += 2
        }
        if a.Block >= 0 {
                args = append(args, "block", int64(a.Block/time.Millisecond))
                keyPos += 2
        }
        if a.NoAck {
                args = append(args, "noack")
                keyPos++
        }
        args = append(args, "streams")
        keyPos++
        for _, s := range a.Streams {
                args = append(args, s)
        }

        cmd := NewXStreamSliceCmd(ctx, args...)
        if a.Block >= 0 {
                cmd.setReadTimeout(a.Block)
        }
        cmd.SetFirstKeyPos(keyPos)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd {
        args := []interface{}{"xack", stream, group}
        for _, id := range ids {
                args = append(args, id)
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XPending(ctx context.Context, stream, group string) *XPendingCmd {
        cmd := NewXPendingCmd(ctx, "xpending", stream, group)
        _ = c(ctx, cmd)
        return cmd
}

type XPendingExtArgs struct {
        Stream   string
        Group    string
        Idle     time.Duration
        Start    string
        End      string
        Count    int64
        Consumer string
}

func (c cmdable) XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd {
        args := make([]interface{}, 0, 9)
        args = append(args, "xpending", a.Stream, a.Group)
        if a.Idle != 0 {
                args = append(args, "idle", formatMs(ctx, a.Idle))
        }
        args = append(args, a.Start, a.End, a.Count)
        if a.Consumer != "" {
                args = append(args, a.Consumer)
        }
        cmd := NewXPendingExtCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type XAutoClaimArgs struct {
        Stream   string
        Group    string
        MinIdle  time.Duration
        Start    string
        Count    int64
        Consumer string
}

func (c cmdable) XAutoClaim(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimCmd {
        args := xAutoClaimArgs(ctx, a)
        cmd := NewXAutoClaimCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XAutoClaimJustID(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimJustIDCmd {
        args := xAutoClaimArgs(ctx, a)
        args = append(args, "justid")
        cmd := NewXAutoClaimJustIDCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func xAutoClaimArgs(ctx context.Context, a *XAutoClaimArgs) []interface{} {
        args := make([]interface{}, 0, 8)
        args = append(args, "xautoclaim", a.Stream, a.Group, a.Consumer, formatMs(ctx, a.MinIdle), a.Start)
        if a.Count > 0 {
                args = append(args, "count", a.Count)
        }
        return args
}

type XClaimArgs struct {
        Stream   string
        Group    string
        Consumer string
        MinIdle  time.Duration
        Messages []string
}

func (c cmdable) XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd {
        args := xClaimArgs(a)
        cmd := NewXMessageSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd {
        args := xClaimArgs(a)
        args = append(args, "justid")
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

func xClaimArgs(a *XClaimArgs) []interface{} {
        args := make([]interface{}, 0, 5+len(a.Messages))
        args = append(args,
                "xclaim",
                a.Stream,
                a.Group, a.Consumer,
                int64(a.MinIdle/time.Millisecond))
        for _, id := range a.Messages {
                args = append(args, id)
        }
        return args
}

// xTrim If approx is true, add the "~" parameter, otherwise it is the default "=" (redis default).
// example:
//
//        XTRIM key MAXLEN/MINID threshold LIMIT limit.
//        XTRIM key MAXLEN/MINID ~ threshold LIMIT limit.
//
// The redis-server version is lower than 6.2, please set limit to 0.
func (c cmdable) xTrim(
        ctx context.Context, key, strategy string,
        approx bool, threshold interface{}, limit int64,
) *IntCmd {
        args := make([]interface{}, 0, 7)
        args = append(args, "xtrim", key, strategy)
        if approx {
                args = append(args, "~")
        }
        args = append(args, threshold)
        if limit > 0 {
                args = append(args, "limit", limit)
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// XTrimMaxLen No `~` rules are used, `limit` cannot be used.
// cmd: XTRIM key MAXLEN maxLen
func (c cmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *IntCmd {
        return c.xTrim(ctx, key, "maxlen", false, maxLen, 0)
}

func (c cmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *IntCmd {
        return c.xTrim(ctx, key, "maxlen", true, maxLen, limit)
}

func (c cmdable) XTrimMinID(ctx context.Context, key string, minID string) *IntCmd {
        return c.xTrim(ctx, key, "minid", false, minID, 0)
}

func (c cmdable) XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *IntCmd {
        return c.xTrim(ctx, key, "minid", true, minID, limit)
}

func (c cmdable) XInfoConsumers(ctx context.Context, key string, group string) *XInfoConsumersCmd {
        cmd := NewXInfoConsumersCmd(ctx, key, group)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd {
        cmd := NewXInfoGroupsCmd(ctx, key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) XInfoStream(ctx context.Context, key string) *XInfoStreamCmd {
        cmd := NewXInfoStreamCmd(ctx, key)
        _ = c(ctx, cmd)
        return cmd
}

// XInfoStreamFull XINFO STREAM FULL [COUNT count]
// redis-server >= 6.0.
func (c cmdable) XInfoStreamFull(ctx context.Context, key string, count int) *XInfoStreamFullCmd {
        args := make([]interface{}, 0, 6)
        args = append(args, "xinfo", "stream", key, "full")
        if count > 0 {
                args = append(args, "count", count)
        }
        cmd := NewXInfoStreamFullCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "time"
)

type StringCmdable interface {
        Append(ctx context.Context, key, value string) *IntCmd
        Decr(ctx context.Context, key string) *IntCmd
        DecrBy(ctx context.Context, key string, decrement int64) *IntCmd
        Get(ctx context.Context, key string) *StringCmd
        GetRange(ctx context.Context, key string, start, end int64) *StringCmd
        GetSet(ctx context.Context, key string, value interface{}) *StringCmd
        GetEx(ctx context.Context, key string, expiration time.Duration) *StringCmd
        GetDel(ctx context.Context, key string) *StringCmd
        Incr(ctx context.Context, key string) *IntCmd
        IncrBy(ctx context.Context, key string, value int64) *IntCmd
        IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd
        LCS(ctx context.Context, q *LCSQuery) *LCSCmd
        MGet(ctx context.Context, keys ...string) *SliceCmd
        MSet(ctx context.Context, values ...interface{}) *StatusCmd
        MSetNX(ctx context.Context, values ...interface{}) *BoolCmd
        Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd
        SetArgs(ctx context.Context, key string, value interface{}, a SetArgs) *StatusCmd
        SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd
        SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd
        SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd
        SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd
        StrLen(ctx context.Context, key string) *IntCmd
}

func (c cmdable) Append(ctx context.Context, key, value string) *IntCmd {
        cmd := NewIntCmd(ctx, "append", key, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Decr(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "decr", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) DecrBy(ctx context.Context, key string, decrement int64) *IntCmd {
        cmd := NewIntCmd(ctx, "decrby", key, decrement)
        _ = c(ctx, cmd)
        return cmd
}

// Get Redis `GET key` command. It returns redis.Nil error when key does not exist.
func (c cmdable) Get(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "get", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) GetRange(ctx context.Context, key string, start, end int64) *StringCmd {
        cmd := NewStringCmd(ctx, "getrange", key, start, end)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) GetSet(ctx context.Context, key string, value interface{}) *StringCmd {
        cmd := NewStringCmd(ctx, "getset", key, value)
        _ = c(ctx, cmd)
        return cmd
}

// GetEx An expiration of zero removes the TTL associated with the key (i.e. GETEX key persist).
// Requires Redis >= 6.2.0.
func (c cmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *StringCmd {
        args := make([]interface{}, 0, 4)
        args = append(args, "getex", key)
        if expiration > 0 {
                if usePrecise(expiration) {
                        args = append(args, "px", formatMs(ctx, expiration))
                } else {
                        args = append(args, "ex", formatSec(ctx, expiration))
                }
        } else if expiration == 0 {
                args = append(args, "persist")
        }

        cmd := NewStringCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// GetDel redis-server version >= 6.2.0.
func (c cmdable) GetDel(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "getdel", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) Incr(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "incr", key)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) IncrBy(ctx context.Context, key string, value int64) *IntCmd {
        cmd := NewIntCmd(ctx, "incrby", key, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd {
        cmd := NewFloatCmd(ctx, "incrbyfloat", key, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) LCS(ctx context.Context, q *LCSQuery) *LCSCmd {
        cmd := NewLCSCmd(ctx, q)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) MGet(ctx context.Context, keys ...string) *SliceCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "mget"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// MSet is like Set but accepts multiple values:
//   - MSet("key1", "value1", "key2", "value2")
//   - MSet([]string{"key1", "value1", "key2", "value2"})
//   - MSet(map[string]interface{}{"key1": "value1", "key2": "value2"})
//   - MSet(struct), For struct types, see HSet description.
func (c cmdable) MSet(ctx context.Context, values ...interface{}) *StatusCmd {
        args := make([]interface{}, 1, 1+len(values))
        args[0] = "mset"
        args = appendArgs(args, values)
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// MSetNX is like SetNX but accepts multiple values:
//   - MSetNX("key1", "value1", "key2", "value2")
//   - MSetNX([]string{"key1", "value1", "key2", "value2"})
//   - MSetNX(map[string]interface{}{"key1": "value1", "key2": "value2"})
//   - MSetNX(struct), For struct types, see HSet description.
func (c cmdable) MSetNX(ctx context.Context, values ...interface{}) *BoolCmd {
        args := make([]interface{}, 1, 1+len(values))
        args[0] = "msetnx"
        args = appendArgs(args, values)
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// Set Redis `SET key value [expiration]` command.
// Use expiration for `SETEx`-like behavior.
//
// Zero expiration means the key has no expiration time.
// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
// otherwise you will receive an error: (error) ERR syntax error.
func (c cmdable) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {
        args := make([]interface{}, 3, 5)
        args[0] = "set"
        args[1] = key
        args[2] = value
        if expiration > 0 {
                if usePrecise(expiration) {
                        args = append(args, "px", formatMs(ctx, expiration))
                } else {
                        args = append(args, "ex", formatSec(ctx, expiration))
                }
        } else if expiration == KeepTTL {
                args = append(args, "keepttl")
        }

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// SetArgs provides arguments for the SetArgs function.
type SetArgs struct {
        // Mode can be `NX` or `XX` or empty.
        Mode string

        // Zero `TTL` or `Expiration` means that the key has no expiration time.
        TTL      time.Duration
        ExpireAt time.Time

        // When Get is true, the command returns the old value stored at key, or nil when key did not exist.
        Get bool

        // KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
        // otherwise you will receive an error: (error) ERR syntax error.
        KeepTTL bool
}

// SetArgs supports all the options that the SET command supports.
// It is the alternative to the Set function when you want
// to have more control over the options.
func (c cmdable) SetArgs(ctx context.Context, key string, value interface{}, a SetArgs) *StatusCmd {
        args := []interface{}{"set", key, value}

        if a.KeepTTL {
                args = append(args, "keepttl")
        }

        if !a.ExpireAt.IsZero() {
                args = append(args, "exat", a.ExpireAt.Unix())
        }
        if a.TTL > 0 {
                if usePrecise(a.TTL) {
                        args = append(args, "px", formatMs(ctx, a.TTL))
                } else {
                        args = append(args, "ex", formatSec(ctx, a.TTL))
                }
        }

        if a.Mode != "" {
                args = append(args, a.Mode)
        }

        if a.Get {
                args = append(args, "get")
        }

        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// SetEx Redis `SETEx key expiration value` command.
func (c cmdable) SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {
        cmd := NewStatusCmd(ctx, "setex", key, formatSec(ctx, expiration), value)
        _ = c(ctx, cmd)
        return cmd
}

// SetNX Redis `SET key value [expiration] NX` command.
//
// Zero expiration means the key has no expiration time.
// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
// otherwise you will receive an error: (error) ERR syntax error.
func (c cmdable) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {
        var cmd *BoolCmd
        switch expiration {
        case 0:
                // Use old `SETNX` to support old Redis versions.
                cmd = NewBoolCmd(ctx, "setnx", key, value)
        case KeepTTL:
                cmd = NewBoolCmd(ctx, "set", key, value, "keepttl", "nx")
        default:
                if usePrecise(expiration) {
                        cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(ctx, expiration), "nx")
                } else {
                        cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(ctx, expiration), "nx")
                }
        }

        _ = c(ctx, cmd)
        return cmd
}

// SetXX Redis `SET key value [expiration] XX` command.
//
// Zero expiration means the key has no expiration time.
// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
// otherwise you will receive an error: (error) ERR syntax error.
func (c cmdable) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {
        var cmd *BoolCmd
        switch expiration {
        case 0:
                cmd = NewBoolCmd(ctx, "set", key, value, "xx")
        case KeepTTL:
                cmd = NewBoolCmd(ctx, "set", key, value, "keepttl", "xx")
        default:
                if usePrecise(expiration) {
                        cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(ctx, expiration), "xx")
                } else {
                        cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(ctx, expiration), "xx")
                }
        }

        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd {
        cmd := NewIntCmd(ctx, "setrange", key, offset, value)
        _ = c(ctx, cmd)
        return cmd
}

func (c cmdable) StrLen(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "strlen", key)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"
        "strconv"

        "github.com/redis/go-redis/v9/internal/proto"
)

type TimeseriesCmdable interface {
        TSAdd(ctx context.Context, key string, timestamp interface{}, value float64) *IntCmd
        TSAddWithArgs(ctx context.Context, key string, timestamp interface{}, value float64, options *TSOptions) *IntCmd
        TSCreate(ctx context.Context, key string) *StatusCmd
        TSCreateWithArgs(ctx context.Context, key string, options *TSOptions) *StatusCmd
        TSAlter(ctx context.Context, key string, options *TSAlterOptions) *StatusCmd
        TSCreateRule(ctx context.Context, sourceKey string, destKey string, aggregator Aggregator, bucketDuration int) *StatusCmd
        TSCreateRuleWithArgs(ctx context.Context, sourceKey string, destKey string, aggregator Aggregator, bucketDuration int, options *TSCreateRuleOptions) *StatusCmd
        TSIncrBy(ctx context.Context, Key string, timestamp float64) *IntCmd
        TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *TSIncrDecrOptions) *IntCmd
        TSDecrBy(ctx context.Context, Key string, timestamp float64) *IntCmd
        TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *TSIncrDecrOptions) *IntCmd
        TSDel(ctx context.Context, Key string, fromTimestamp int, toTimestamp int) *IntCmd
        TSDeleteRule(ctx context.Context, sourceKey string, destKey string) *StatusCmd
        TSGet(ctx context.Context, key string) *TSTimestampValueCmd
        TSGetWithArgs(ctx context.Context, key string, options *TSGetOptions) *TSTimestampValueCmd
        TSInfo(ctx context.Context, key string) *MapStringInterfaceCmd
        TSInfoWithArgs(ctx context.Context, key string, options *TSInfoOptions) *MapStringInterfaceCmd
        TSMAdd(ctx context.Context, ktvSlices [][]interface{}) *IntSliceCmd
        TSQueryIndex(ctx context.Context, filterExpr []string) *StringSliceCmd
        TSRevRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *TSTimestampValueSliceCmd
        TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *TSRevRangeOptions) *TSTimestampValueSliceCmd
        TSRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *TSTimestampValueSliceCmd
        TSRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *TSRangeOptions) *TSTimestampValueSliceCmd
        TSMRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *MapStringSliceInterfaceCmd
        TSMRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *TSMRangeOptions) *MapStringSliceInterfaceCmd
        TSMRevRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *MapStringSliceInterfaceCmd
        TSMRevRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *TSMRevRangeOptions) *MapStringSliceInterfaceCmd
        TSMGet(ctx context.Context, filters []string) *MapStringSliceInterfaceCmd
        TSMGetWithArgs(ctx context.Context, filters []string, options *TSMGetOptions) *MapStringSliceInterfaceCmd
}

type TSOptions struct {
        Retention         int
        ChunkSize         int
        Encoding          string
        DuplicatePolicy   string
        Labels            map[string]string
        IgnoreMaxTimeDiff int64
        IgnoreMaxValDiff  float64
}
type TSIncrDecrOptions struct {
        Timestamp         int64
        Retention         int
        ChunkSize         int
        Uncompressed      bool
        DuplicatePolicy   string
        Labels            map[string]string
        IgnoreMaxTimeDiff int64
        IgnoreMaxValDiff  float64
}

type TSAlterOptions struct {
        Retention         int
        ChunkSize         int
        DuplicatePolicy   string
        Labels            map[string]string
        IgnoreMaxTimeDiff int64
        IgnoreMaxValDiff  float64
}

type TSCreateRuleOptions struct {
        alignTimestamp int64
}

type TSGetOptions struct {
        Latest bool
}

type TSInfoOptions struct {
        Debug bool
}
type Aggregator int

const (
        Invalid = Aggregator(iota)
        Avg
        Sum
        Min
        Max
        Range
        Count
        First
        Last
        StdP
        StdS
        VarP
        VarS
        Twa
)

func (a Aggregator) String() string {
        switch a {
        case Invalid:
                return ""
        case Avg:
                return "AVG"
        case Sum:
                return "SUM"
        case Min:
                return "MIN"
        case Max:
                return "MAX"
        case Range:
                return "RANGE"
        case Count:
                return "COUNT"
        case First:
                return "FIRST"
        case Last:
                return "LAST"
        case StdP:
                return "STD.P"
        case StdS:
                return "STD.S"
        case VarP:
                return "VAR.P"
        case VarS:
                return "VAR.S"
        case Twa:
                return "TWA"
        default:
                return ""
        }
}

type TSRangeOptions struct {
        Latest          bool
        FilterByTS      []int
        FilterByValue   []int
        Count           int
        Align           interface{}
        Aggregator      Aggregator
        BucketDuration  int
        BucketTimestamp interface{}
        Empty           bool
}

type TSRevRangeOptions struct {
        Latest          bool
        FilterByTS      []int
        FilterByValue   []int
        Count           int
        Align           interface{}
        Aggregator      Aggregator
        BucketDuration  int
        BucketTimestamp interface{}
        Empty           bool
}

type TSMRangeOptions struct {
        Latest          bool
        FilterByTS      []int
        FilterByValue   []int
        WithLabels      bool
        SelectedLabels  []interface{}
        Count           int
        Align           interface{}
        Aggregator      Aggregator
        BucketDuration  int
        BucketTimestamp interface{}
        Empty           bool
        GroupByLabel    interface{}
        Reducer         interface{}
}

type TSMRevRangeOptions struct {
        Latest          bool
        FilterByTS      []int
        FilterByValue   []int
        WithLabels      bool
        SelectedLabels  []interface{}
        Count           int
        Align           interface{}
        Aggregator      Aggregator
        BucketDuration  int
        BucketTimestamp interface{}
        Empty           bool
        GroupByLabel    interface{}
        Reducer         interface{}
}

type TSMGetOptions struct {
        Latest         bool
        WithLabels     bool
        SelectedLabels []interface{}
}

// TSAdd - Adds one or more observations to a t-digest sketch.
// For more information - https://redis.io/commands/ts.add/
func (c cmdable) TSAdd(ctx context.Context, key string, timestamp interface{}, value float64) *IntCmd {
        args := []interface{}{"TS.ADD", key, timestamp, value}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSAddWithArgs - Adds one or more observations to a t-digest sketch.
// This function also allows for specifying additional options such as:
// Retention, ChunkSize, Encoding, DuplicatePolicy and Labels.
// For more information - https://redis.io/commands/ts.add/
func (c cmdable) TSAddWithArgs(ctx context.Context, key string, timestamp interface{}, value float64, options *TSOptions) *IntCmd {
        args := []interface{}{"TS.ADD", key, timestamp, value}
        if options != nil {
                if options.Retention != 0 {
                        args = append(args, "RETENTION", options.Retention)
                }
                if options.ChunkSize != 0 {
                        args = append(args, "CHUNK_SIZE", options.ChunkSize)
                }
                if options.Encoding != "" {
                        args = append(args, "ENCODING", options.Encoding)
                }

                if options.DuplicatePolicy != "" {
                        args = append(args, "DUPLICATE_POLICY", options.DuplicatePolicy)
                }
                if options.Labels != nil {
                        args = append(args, "LABELS")
                        for label, value := range options.Labels {
                                args = append(args, label, value)
                        }
                }
                if options.IgnoreMaxTimeDiff != 0 || options.IgnoreMaxValDiff != 0 {
                        args = append(args, "IGNORE", options.IgnoreMaxTimeDiff, options.IgnoreMaxValDiff)
                }
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSCreate - Creates a new time-series key.
// For more information - https://redis.io/commands/ts.create/
func (c cmdable) TSCreate(ctx context.Context, key string) *StatusCmd {
        args := []interface{}{"TS.CREATE", key}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSCreateWithArgs - Creates a new time-series key with additional options.
// This function allows for specifying additional options such as:
// Retention, ChunkSize, Encoding, DuplicatePolicy and Labels.
// For more information - https://redis.io/commands/ts.create/
func (c cmdable) TSCreateWithArgs(ctx context.Context, key string, options *TSOptions) *StatusCmd {
        args := []interface{}{"TS.CREATE", key}
        if options != nil {
                if options.Retention != 0 {
                        args = append(args, "RETENTION", options.Retention)
                }
                if options.ChunkSize != 0 {
                        args = append(args, "CHUNK_SIZE", options.ChunkSize)
                }
                if options.Encoding != "" {
                        args = append(args, "ENCODING", options.Encoding)
                }

                if options.DuplicatePolicy != "" {
                        args = append(args, "DUPLICATE_POLICY", options.DuplicatePolicy)
                }
                if options.Labels != nil {
                        args = append(args, "LABELS")
                        for label, value := range options.Labels {
                                args = append(args, label, value)
                        }
                }
                if options.IgnoreMaxTimeDiff != 0 || options.IgnoreMaxValDiff != 0 {
                        args = append(args, "IGNORE", options.IgnoreMaxTimeDiff, options.IgnoreMaxValDiff)
                }
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSAlter - Alters an existing time-series key with additional options.
// This function allows for specifying additional options such as:
// Retention, ChunkSize and DuplicatePolicy.
// For more information - https://redis.io/commands/ts.alter/
func (c cmdable) TSAlter(ctx context.Context, key string, options *TSAlterOptions) *StatusCmd {
        args := []interface{}{"TS.ALTER", key}
        if options != nil {
                if options.Retention != 0 {
                        args = append(args, "RETENTION", options.Retention)
                }
                if options.ChunkSize != 0 {
                        args = append(args, "CHUNK_SIZE", options.ChunkSize)
                }
                if options.DuplicatePolicy != "" {
                        args = append(args, "DUPLICATE_POLICY", options.DuplicatePolicy)
                }
                if options.Labels != nil {
                        args = append(args, "LABELS")
                        for label, value := range options.Labels {
                                args = append(args, label, value)
                        }
                }
                if options.IgnoreMaxTimeDiff != 0 || options.IgnoreMaxValDiff != 0 {
                        args = append(args, "IGNORE", options.IgnoreMaxTimeDiff, options.IgnoreMaxValDiff)
                }
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSCreateRule - Creates a compaction rule from sourceKey to destKey.
// For more information - https://redis.io/commands/ts.createrule/
func (c cmdable) TSCreateRule(ctx context.Context, sourceKey string, destKey string, aggregator Aggregator, bucketDuration int) *StatusCmd {
        args := []interface{}{"TS.CREATERULE", sourceKey, destKey, "AGGREGATION", aggregator.String(), bucketDuration}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSCreateRuleWithArgs - Creates a compaction rule from sourceKey to destKey with additional option.
// This function allows for specifying additional option such as:
// alignTimestamp.
// For more information - https://redis.io/commands/ts.createrule/
func (c cmdable) TSCreateRuleWithArgs(ctx context.Context, sourceKey string, destKey string, aggregator Aggregator, bucketDuration int, options *TSCreateRuleOptions) *StatusCmd {
        args := []interface{}{"TS.CREATERULE", sourceKey, destKey, "AGGREGATION", aggregator.String(), bucketDuration}
        if options != nil {
                if options.alignTimestamp != 0 {
                        args = append(args, options.alignTimestamp)
                }
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSIncrBy - Increments the value of a time-series key by the specified timestamp.
// For more information - https://redis.io/commands/ts.incrby/
func (c cmdable) TSIncrBy(ctx context.Context, Key string, timestamp float64) *IntCmd {
        args := []interface{}{"TS.INCRBY", Key, timestamp}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSIncrByWithArgs - Increments the value of a time-series key by the specified timestamp with additional options.
// This function allows for specifying additional options such as:
// Timestamp, Retention, ChunkSize, Uncompressed and Labels.
// For more information - https://redis.io/commands/ts.incrby/
func (c cmdable) TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *TSIncrDecrOptions) *IntCmd {
        args := []interface{}{"TS.INCRBY", key, timestamp}
        if options != nil {
                if options.Timestamp != 0 {
                        args = append(args, "TIMESTAMP", options.Timestamp)
                }
                if options.Retention != 0 {
                        args = append(args, "RETENTION", options.Retention)
                }
                if options.ChunkSize != 0 {
                        args = append(args, "CHUNK_SIZE", options.ChunkSize)
                }
                if options.Uncompressed {
                        args = append(args, "UNCOMPRESSED")
                }
                if options.DuplicatePolicy != "" {
                        args = append(args, "DUPLICATE_POLICY", options.DuplicatePolicy)
                }
                if options.Labels != nil {
                        args = append(args, "LABELS")
                        for label, value := range options.Labels {
                                args = append(args, label, value)
                        }
                }
                if options.IgnoreMaxTimeDiff != 0 || options.IgnoreMaxValDiff != 0 {
                        args = append(args, "IGNORE", options.IgnoreMaxTimeDiff, options.IgnoreMaxValDiff)
                }
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSDecrBy - Decrements the value of a time-series key by the specified timestamp.
// For more information - https://redis.io/commands/ts.decrby/
func (c cmdable) TSDecrBy(ctx context.Context, Key string, timestamp float64) *IntCmd {
        args := []interface{}{"TS.DECRBY", Key, timestamp}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSDecrByWithArgs - Decrements the value of a time-series key by the specified timestamp with additional options.
// This function allows for specifying additional options such as:
// Timestamp, Retention, ChunkSize, Uncompressed and Labels.
// For more information - https://redis.io/commands/ts.decrby/
func (c cmdable) TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *TSIncrDecrOptions) *IntCmd {
        args := []interface{}{"TS.DECRBY", key, timestamp}
        if options != nil {
                if options.Timestamp != 0 {
                        args = append(args, "TIMESTAMP", options.Timestamp)
                }
                if options.Retention != 0 {
                        args = append(args, "RETENTION", options.Retention)
                }
                if options.ChunkSize != 0 {
                        args = append(args, "CHUNK_SIZE", options.ChunkSize)
                }
                if options.Uncompressed {
                        args = append(args, "UNCOMPRESSED")
                }
                if options.DuplicatePolicy != "" {
                        args = append(args, "DUPLICATE_POLICY", options.DuplicatePolicy)
                }
                if options.Labels != nil {
                        args = append(args, "LABELS")
                        for label, value := range options.Labels {
                                args = append(args, label, value)
                        }
                }
                if options.IgnoreMaxTimeDiff != 0 || options.IgnoreMaxValDiff != 0 {
                        args = append(args, "IGNORE", options.IgnoreMaxTimeDiff, options.IgnoreMaxValDiff)
                }
        }
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSDel - Deletes a range of samples from a time-series key.
// For more information - https://redis.io/commands/ts.del/
func (c cmdable) TSDel(ctx context.Context, Key string, fromTimestamp int, toTimestamp int) *IntCmd {
        args := []interface{}{"TS.DEL", Key, fromTimestamp, toTimestamp}
        cmd := NewIntCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSDeleteRule - Deletes a compaction rule from sourceKey to destKey.
// For more information - https://redis.io/commands/ts.deleterule/
func (c cmdable) TSDeleteRule(ctx context.Context, sourceKey string, destKey string) *StatusCmd {
        args := []interface{}{"TS.DELETERULE", sourceKey, destKey}
        cmd := NewStatusCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSGetWithArgs - Gets the last sample of a time-series key with additional option.
// This function allows for specifying additional option such as:
// Latest.
// For more information - https://redis.io/commands/ts.get/
func (c cmdable) TSGetWithArgs(ctx context.Context, key string, options *TSGetOptions) *TSTimestampValueCmd {
        args := []interface{}{"TS.GET", key}
        if options != nil {
                if options.Latest {
                        args = append(args, "LATEST")
                }
        }
        cmd := newTSTimestampValueCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSGet - Gets the last sample of a time-series key.
// For more information - https://redis.io/commands/ts.get/
func (c cmdable) TSGet(ctx context.Context, key string) *TSTimestampValueCmd {
        args := []interface{}{"TS.GET", key}
        cmd := newTSTimestampValueCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type TSTimestampValue struct {
        Timestamp int64
        Value     float64
}
type TSTimestampValueCmd struct {
        baseCmd
        val TSTimestampValue
}

func newTSTimestampValueCmd(ctx context.Context, args ...interface{}) *TSTimestampValueCmd {
        return &TSTimestampValueCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *TSTimestampValueCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *TSTimestampValueCmd) SetVal(val TSTimestampValue) {
        cmd.val = val
}

func (cmd *TSTimestampValueCmd) Result() (TSTimestampValue, error) {
        return cmd.val, cmd.err
}

func (cmd *TSTimestampValueCmd) Val() TSTimestampValue {
        return cmd.val
}

func (cmd *TSTimestampValueCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadMapLen()
        if err != nil {
                return err
        }
        cmd.val = TSTimestampValue{}
        for i := 0; i < n; i++ {
                timestamp, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                value, err := rd.ReadString()
                if err != nil {
                        return err
                }
                cmd.val.Timestamp = timestamp
                cmd.val.Value, err = strconv.ParseFloat(value, 64)
                if err != nil {
                        return err
                }
        }

        return nil
}

// TSInfo - Returns information about a time-series key.
// For more information - https://redis.io/commands/ts.info/
func (c cmdable) TSInfo(ctx context.Context, key string) *MapStringInterfaceCmd {
        args := []interface{}{"TS.INFO", key}
        cmd := NewMapStringInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSInfoWithArgs - Returns information about a time-series key with additional option.
// This function allows for specifying additional option such as:
// Debug.
// For more information - https://redis.io/commands/ts.info/
func (c cmdable) TSInfoWithArgs(ctx context.Context, key string, options *TSInfoOptions) *MapStringInterfaceCmd {
        args := []interface{}{"TS.INFO", key}
        if options != nil {
                if options.Debug {
                        args = append(args, "DEBUG")
                }
        }
        cmd := NewMapStringInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSMAdd - Adds multiple samples to multiple time-series keys.
// It accepts a slice of 'ktv' slices, each containing exactly three elements: key, timestamp, and value.
// This struct must be provided for this command to work.
// For more information - https://redis.io/commands/ts.madd/
func (c cmdable) TSMAdd(ctx context.Context, ktvSlices [][]interface{}) *IntSliceCmd {
        args := []interface{}{"TS.MADD"}
        for _, ktv := range ktvSlices {
                args = append(args, ktv...)
        }
        cmd := NewIntSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSQueryIndex - Returns all the keys matching the filter expression.
// For more information - https://redis.io/commands/ts.queryindex/
func (c cmdable) TSQueryIndex(ctx context.Context, filterExpr []string) *StringSliceCmd {
        args := []interface{}{"TS.QUERYINDEX"}
        for _, f := range filterExpr {
                args = append(args, f)
        }
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSRevRange - Returns a range of samples from a time-series key in reverse order.
// For more information - https://redis.io/commands/ts.revrange/
func (c cmdable) TSRevRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *TSTimestampValueSliceCmd {
        args := []interface{}{"TS.REVRANGE", key, fromTimestamp, toTimestamp}
        cmd := newTSTimestampValueSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSRevRangeWithArgs - Returns a range of samples from a time-series key in reverse order with additional options.
// This function allows for specifying additional options such as:
// Latest, FilterByTS, FilterByValue, Count, Align, Aggregator,
// BucketDuration, BucketTimestamp and Empty.
// For more information - https://redis.io/commands/ts.revrange/
func (c cmdable) TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *TSRevRangeOptions) *TSTimestampValueSliceCmd {
        args := []interface{}{"TS.REVRANGE", key, fromTimestamp, toTimestamp}
        if options != nil {
                if options.Latest {
                        args = append(args, "LATEST")
                }
                if options.FilterByTS != nil {
                        args = append(args, "FILTER_BY_TS")
                        for _, f := range options.FilterByTS {
                                args = append(args, f)
                        }
                }
                if options.FilterByValue != nil {
                        args = append(args, "FILTER_BY_VALUE")
                        for _, f := range options.FilterByValue {
                                args = append(args, f)
                        }
                }
                if options.Count != 0 {
                        args = append(args, "COUNT", options.Count)
                }
                if options.Align != nil {
                        args = append(args, "ALIGN", options.Align)
                }
                if options.Aggregator != 0 {
                        args = append(args, "AGGREGATION", options.Aggregator.String())
                }
                if options.BucketDuration != 0 {
                        args = append(args, options.BucketDuration)
                }
                if options.BucketTimestamp != nil {
                        args = append(args, "BUCKETTIMESTAMP", options.BucketTimestamp)
                }
                if options.Empty {
                        args = append(args, "EMPTY")
                }
        }
        cmd := newTSTimestampValueSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSRange - Returns a range of samples from a time-series key.
// For more information - https://redis.io/commands/ts.range/
func (c cmdable) TSRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *TSTimestampValueSliceCmd {
        args := []interface{}{"TS.RANGE", key, fromTimestamp, toTimestamp}
        cmd := newTSTimestampValueSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSRangeWithArgs - Returns a range of samples from a time-series key with additional options.
// This function allows for specifying additional options such as:
// Latest, FilterByTS, FilterByValue, Count, Align, Aggregator,
// BucketDuration, BucketTimestamp and Empty.
// For more information - https://redis.io/commands/ts.range/
func (c cmdable) TSRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *TSRangeOptions) *TSTimestampValueSliceCmd {
        args := []interface{}{"TS.RANGE", key, fromTimestamp, toTimestamp}
        if options != nil {
                if options.Latest {
                        args = append(args, "LATEST")
                }
                if options.FilterByTS != nil {
                        args = append(args, "FILTER_BY_TS")
                        for _, f := range options.FilterByTS {
                                args = append(args, f)
                        }
                }
                if options.FilterByValue != nil {
                        args = append(args, "FILTER_BY_VALUE")
                        for _, f := range options.FilterByValue {
                                args = append(args, f)
                        }
                }
                if options.Count != 0 {
                        args = append(args, "COUNT", options.Count)
                }
                if options.Align != nil {
                        args = append(args, "ALIGN", options.Align)
                }
                if options.Aggregator != 0 {
                        args = append(args, "AGGREGATION", options.Aggregator.String())
                }
                if options.BucketDuration != 0 {
                        args = append(args, options.BucketDuration)
                }
                if options.BucketTimestamp != nil {
                        args = append(args, "BUCKETTIMESTAMP", options.BucketTimestamp)
                }
                if options.Empty {
                        args = append(args, "EMPTY")
                }
        }
        cmd := newTSTimestampValueSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

type TSTimestampValueSliceCmd struct {
        baseCmd
        val []TSTimestampValue
}

func newTSTimestampValueSliceCmd(ctx context.Context, args ...interface{}) *TSTimestampValueSliceCmd {
        return &TSTimestampValueSliceCmd{
                baseCmd: baseCmd{
                        ctx:  ctx,
                        args: args,
                },
        }
}

func (cmd *TSTimestampValueSliceCmd) String() string {
        return cmdString(cmd, cmd.val)
}

func (cmd *TSTimestampValueSliceCmd) SetVal(val []TSTimestampValue) {
        cmd.val = val
}

func (cmd *TSTimestampValueSliceCmd) Result() ([]TSTimestampValue, error) {
        return cmd.val, cmd.err
}

func (cmd *TSTimestampValueSliceCmd) Val() []TSTimestampValue {
        return cmd.val
}

func (cmd *TSTimestampValueSliceCmd) readReply(rd *proto.Reader) (err error) {
        n, err := rd.ReadArrayLen()
        if err != nil {
                return err
        }
        cmd.val = make([]TSTimestampValue, n)
        for i := 0; i < n; i++ {
                _, _ = rd.ReadArrayLen()
                timestamp, err := rd.ReadInt()
                if err != nil {
                        return err
                }
                value, err := rd.ReadString()
                if err != nil {
                        return err
                }
                cmd.val[i].Timestamp = timestamp
                cmd.val[i].Value, err = strconv.ParseFloat(value, 64)
                if err != nil {
                        return err
                }
        }

        return nil
}

// TSMRange - Returns a range of samples from multiple time-series keys.
// For more information - https://redis.io/commands/ts.mrange/
func (c cmdable) TSMRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *MapStringSliceInterfaceCmd {
        args := []interface{}{"TS.MRANGE", fromTimestamp, toTimestamp, "FILTER"}
        for _, f := range filterExpr {
                args = append(args, f)
        }
        cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSMRangeWithArgs - Returns a range of samples from multiple time-series keys with additional options.
// This function allows for specifying additional options such as:
// Latest, FilterByTS, FilterByValue, WithLabels, SelectedLabels,
// Count, Align, Aggregator, BucketDuration, BucketTimestamp,
// Empty, GroupByLabel and Reducer.
// For more information - https://redis.io/commands/ts.mrange/
func (c cmdable) TSMRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *TSMRangeOptions) *MapStringSliceInterfaceCmd {
        args := []interface{}{"TS.MRANGE", fromTimestamp, toTimestamp}
        if options != nil {
                if options.Latest {
                        args = append(args, "LATEST")
                }
                if options.FilterByTS != nil {
                        args = append(args, "FILTER_BY_TS")
                        for _, f := range options.FilterByTS {
                                args = append(args, f)
                        }
                }
                if options.FilterByValue != nil {
                        args = append(args, "FILTER_BY_VALUE")
                        for _, f := range options.FilterByValue {
                                args = append(args, f)
                        }
                }
                if options.WithLabels {
                        args = append(args, "WITHLABELS")
                }
                if options.SelectedLabels != nil {
                        args = append(args, "SELECTED_LABELS")
                        args = append(args, options.SelectedLabels...)
                }
                if options.Count != 0 {
                        args = append(args, "COUNT", options.Count)
                }
                if options.Align != nil {
                        args = append(args, "ALIGN", options.Align)
                }
                if options.Aggregator != 0 {
                        args = append(args, "AGGREGATION", options.Aggregator.String())
                }
                if options.BucketDuration != 0 {
                        args = append(args, options.BucketDuration)
                }
                if options.BucketTimestamp != nil {
                        args = append(args, "BUCKETTIMESTAMP", options.BucketTimestamp)
                }
                if options.Empty {
                        args = append(args, "EMPTY")
                }
        }
        args = append(args, "FILTER")
        for _, f := range filterExpr {
                args = append(args, f)
        }
        if options != nil {
                if options.GroupByLabel != nil {
                        args = append(args, "GROUPBY", options.GroupByLabel)
                }
                if options.Reducer != nil {
                        args = append(args, "REDUCE", options.Reducer)
                }
        }
        cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSMRevRange - Returns a range of samples from multiple time-series keys in reverse order.
// For more information - https://redis.io/commands/ts.mrevrange/
func (c cmdable) TSMRevRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *MapStringSliceInterfaceCmd {
        args := []interface{}{"TS.MREVRANGE", fromTimestamp, toTimestamp, "FILTER"}
        for _, f := range filterExpr {
                args = append(args, f)
        }
        cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSMRevRangeWithArgs - Returns a range of samples from multiple time-series keys in reverse order with additional options.
// This function allows for specifying additional options such as:
// Latest, FilterByTS, FilterByValue, WithLabels, SelectedLabels,
// Count, Align, Aggregator, BucketDuration, BucketTimestamp,
// Empty, GroupByLabel and Reducer.
// For more information - https://redis.io/commands/ts.mrevrange/
func (c cmdable) TSMRevRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *TSMRevRangeOptions) *MapStringSliceInterfaceCmd {
        args := []interface{}{"TS.MREVRANGE", fromTimestamp, toTimestamp}
        if options != nil {
                if options.Latest {
                        args = append(args, "LATEST")
                }
                if options.FilterByTS != nil {
                        args = append(args, "FILTER_BY_TS")
                        for _, f := range options.FilterByTS {
                                args = append(args, f)
                        }
                }
                if options.FilterByValue != nil {
                        args = append(args, "FILTER_BY_VALUE")
                        for _, f := range options.FilterByValue {
                                args = append(args, f)
                        }
                }
                if options.WithLabels {
                        args = append(args, "WITHLABELS")
                }
                if options.SelectedLabels != nil {
                        args = append(args, "SELECTED_LABELS")
                        args = append(args, options.SelectedLabels...)
                }
                if options.Count != 0 {
                        args = append(args, "COUNT", options.Count)
                }
                if options.Align != nil {
                        args = append(args, "ALIGN", options.Align)
                }
                if options.Aggregator != 0 {
                        args = append(args, "AGGREGATION", options.Aggregator.String())
                }
                if options.BucketDuration != 0 {
                        args = append(args, options.BucketDuration)
                }
                if options.BucketTimestamp != nil {
                        args = append(args, "BUCKETTIMESTAMP", options.BucketTimestamp)
                }
                if options.Empty {
                        args = append(args, "EMPTY")
                }
        }
        args = append(args, "FILTER")
        for _, f := range filterExpr {
                args = append(args, f)
        }
        if options != nil {
                if options.GroupByLabel != nil {
                        args = append(args, "GROUPBY", options.GroupByLabel)
                }
                if options.Reducer != nil {
                        args = append(args, "REDUCE", options.Reducer)
                }
        }
        cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSMGet - Returns the last sample of multiple time-series keys.
// For more information - https://redis.io/commands/ts.mget/
func (c cmdable) TSMGet(ctx context.Context, filters []string) *MapStringSliceInterfaceCmd {
        args := []interface{}{"TS.MGET", "FILTER"}
        for _, f := range filters {
                args = append(args, f)
        }
        cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// TSMGetWithArgs - Returns the last sample of multiple time-series keys with additional options.
// This function allows for specifying additional options such as:
// Latest, WithLabels and SelectedLabels.
// For more information - https://redis.io/commands/ts.mget/
func (c cmdable) TSMGetWithArgs(ctx context.Context, filters []string, options *TSMGetOptions) *MapStringSliceInterfaceCmd {
        args := []interface{}{"TS.MGET"}
        if options != nil {
                if options.Latest {
                        args = append(args, "LATEST")
                }
                if options.WithLabels {
                        args = append(args, "WITHLABELS")
                }
                if options.SelectedLabels != nil {
                        args = append(args, "SELECTED_LABELS")
                        args = append(args, options.SelectedLabels...)
                }
        }
        args = append(args, "FILTER")
        for _, f := range filters {
                args = append(args, f)
        }
        cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package redis

import (
        "context"

        "github.com/redis/go-redis/v9/internal/pool"
        "github.com/redis/go-redis/v9/internal/proto"
)

// TxFailedErr transaction redis failed.
const TxFailedErr = proto.RedisError("redis: transaction failed")

// Tx implements Redis transactions as described in
// http://redis.io/topics/transactions. It's NOT safe for concurrent use
// by multiple goroutines, because Exec resets list of watched keys.
//
// If you don't need WATCH, use Pipeline instead.
type Tx struct {
        baseClient
        cmdable
        statefulCmdable
}

func (c *Client) newTx() *Tx {
        tx := Tx{
                baseClient: baseClient{
                        opt:        c.opt,
                        connPool:   pool.NewStickyConnPool(c.connPool),
                        hooksMixin: c.hooksMixin.clone(),
                },
        }
        tx.init()
        return &tx
}

func (c *Tx) init() {
        c.cmdable = c.Process
        c.statefulCmdable = c.Process

        c.initHooks(hooks{
                dial:       c.baseClient.dial,
                process:    c.baseClient.process,
                pipeline:   c.baseClient.processPipeline,
                txPipeline: c.baseClient.processTxPipeline,
        })
}

func (c *Tx) Process(ctx context.Context, cmd Cmder) error {
        err := c.processHook(ctx, cmd)
        cmd.SetErr(err)
        return err
}

// Watch prepares a transaction and marks the keys to be watched
// for conditional execution if there are any keys.
//
// The transaction is automatically closed when fn exits.
func (c *Client) Watch(ctx context.Context, fn func(*Tx) error, keys ...string) error {
        tx := c.newTx()
        defer tx.Close(ctx)
        if len(keys) > 0 {
                if err := tx.Watch(ctx, keys...).Err(); err != nil {
                        return err
                }
        }
        return fn(tx)
}

// Close closes the transaction, releasing any open resources.
func (c *Tx) Close(ctx context.Context) error {
        _ = c.Unwatch(ctx).Err()
        return c.baseClient.Close()
}

// Watch marks the keys to be watched for conditional execution
// of a transaction.
func (c *Tx) Watch(ctx context.Context, keys ...string) *StatusCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "watch"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c.Process(ctx, cmd)
        return cmd
}

// Unwatch flushes all the previously watched keys for a transaction.
func (c *Tx) Unwatch(ctx context.Context, keys ...string) *StatusCmd {
        args := make([]interface{}, 1+len(keys))
        args[0] = "unwatch"
        for i, key := range keys {
                args[1+i] = key
        }
        cmd := NewStatusCmd(ctx, args...)
        _ = c.Process(ctx, cmd)
        return cmd
}

// Pipeline creates a pipeline. Usually it is more convenient to use Pipelined.
func (c *Tx) Pipeline() Pipeliner {
        pipe := Pipeline{
                exec: func(ctx context.Context, cmds []Cmder) error {
                        return c.processPipelineHook(ctx, cmds)
                },
        }
        pipe.init()
        return &pipe
}

// Pipelined executes commands queued in the fn outside of the transaction.
// Use TxPipelined if you need transactional behavior.
func (c *Tx) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.Pipeline().Pipelined(ctx, fn)
}

// TxPipelined executes commands queued in the fn in the transaction.
//
// When using WATCH, EXEC will execute commands only if the watched keys
// were not modified, allowing for a check-and-set mechanism.
//
// Exec always returns list of commands. If transaction fails
// TxFailedErr is returned. Otherwise Exec returns an error of the first
// failed command or nil.
func (c *Tx) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
        return c.TxPipeline().Pipelined(ctx, fn)
}

// TxPipeline creates a pipeline. Usually it is more convenient to use TxPipelined.
func (c *Tx) TxPipeline() Pipeliner {
        pipe := Pipeline{
                exec: func(ctx context.Context, cmds []Cmder) error {
                        cmds = wrapMultiExec(ctx, cmds)
                        return c.processTxPipelineHook(ctx, cmds)
                },
        }
        pipe.init()
        return &pipe
}

func wrapMultiExec(ctx context.Context, cmds []Cmder) []Cmder {
        if len(cmds) == 0 {
                panic("not reached")
        }
        cmdsCopy := make([]Cmder, len(cmds)+2)
        cmdsCopy[0] = NewStatusCmd(ctx, "multi")
        copy(cmdsCopy[1:], cmds)
        cmdsCopy[len(cmdsCopy)-1] = NewSliceCmd(ctx, "exec")
        return cmdsCopy
}

package redis

import (
        "context"
        "crypto/tls"
        "net"
        "time"

        "github.com/redis/go-redis/v9/auth"
)

// UniversalOptions information is required by UniversalClient to establish
// connections.
type UniversalOptions struct {
        // Either a single address or a seed list of host:port addresses
        // of cluster/sentinel nodes.
        Addrs []string

        // ClientName will execute the `CLIENT SETNAME ClientName` command for each conn.
        ClientName string

        // Database to be selected after connecting to the server.
        // Only single-node and failover clients.
        DB int

        // Common options.

        Dialer    func(ctx context.Context, network, addr string) (net.Conn, error)
        OnConnect func(ctx context.Context, cn *Conn) error

        Protocol int
        Username string
        Password string
        // CredentialsProvider allows the username and password to be updated
        // before reconnecting. It should return the current username and password.
        CredentialsProvider func() (username string, password string)

        // CredentialsProviderContext is an enhanced parameter of CredentialsProvider,
        // done to maintain API compatibility. In the future,
        // there might be a merge between CredentialsProviderContext and CredentialsProvider.
        // There will be a conflict between them; if CredentialsProviderContext exists, we will ignore CredentialsProvider.
        CredentialsProviderContext func(ctx context.Context) (username string, password string, err error)

        // StreamingCredentialsProvider is used to retrieve the credentials
        // for the connection from an external source. Those credentials may change
        // during the connection lifetime. This is useful for managed identity
        // scenarios where the credentials are retrieved from an external source.
        //
        // Currently, this is a placeholder for the future implementation.
        StreamingCredentialsProvider auth.StreamingCredentialsProvider

        SentinelUsername string
        SentinelPassword string

        MaxRetries      int
        MinRetryBackoff time.Duration
        MaxRetryBackoff time.Duration

        DialTimeout           time.Duration
        ReadTimeout           time.Duration
        WriteTimeout          time.Duration
        ContextTimeoutEnabled bool

        // PoolFIFO uses FIFO mode for each node connection pool GET/PUT (default LIFO).
        PoolFIFO bool

        PoolSize        int
        PoolTimeout     time.Duration
        MinIdleConns    int
        MaxIdleConns    int
        MaxActiveConns  int
        ConnMaxIdleTime time.Duration
        ConnMaxLifetime time.Duration

        TLSConfig *tls.Config

        // Only cluster clients.

        MaxRedirects   int
        ReadOnly       bool
        RouteByLatency bool
        RouteRandomly  bool

        // MasterName is the sentinel master name.
        // Only for failover clients.
        MasterName string

        // DisableIndentity - Disable set-lib on connect.
        //
        // default: false
        //
        // Deprecated: Use DisableIdentity instead.
        DisableIndentity bool

        // DisableIdentity is used to disable CLIENT SETINFO command on connect.
        //
        // default: false
        DisableIdentity bool

        IdentitySuffix string
        UnstableResp3  bool

        // IsClusterMode can be used when only one Addrs is provided (e.g. Elasticache supports setting up cluster mode with configuration endpoint).
        IsClusterMode bool
}

// Cluster returns cluster options created from the universal options.
func (o *UniversalOptions) Cluster() *ClusterOptions {
        if len(o.Addrs) == 0 {
                o.Addrs = []string{"127.0.0.1:6379"}
        }

        return &ClusterOptions{
                Addrs:      o.Addrs,
                ClientName: o.ClientName,
                Dialer:     o.Dialer,
                OnConnect:  o.OnConnect,

                Protocol:                     o.Protocol,
                Username:                     o.Username,
                Password:                     o.Password,
                CredentialsProvider:          o.CredentialsProvider,
                CredentialsProviderContext:   o.CredentialsProviderContext,
                StreamingCredentialsProvider: o.StreamingCredentialsProvider,

                MaxRedirects:   o.MaxRedirects,
                ReadOnly:       o.ReadOnly,
                RouteByLatency: o.RouteByLatency,
                RouteRandomly:  o.RouteRandomly,

                MaxRetries:      o.MaxRetries,
                MinRetryBackoff: o.MinRetryBackoff,
                MaxRetryBackoff: o.MaxRetryBackoff,

                DialTimeout:           o.DialTimeout,
                ReadTimeout:           o.ReadTimeout,
                WriteTimeout:          o.WriteTimeout,
                ContextTimeoutEnabled: o.ContextTimeoutEnabled,

                PoolFIFO: o.PoolFIFO,

                PoolSize:        o.PoolSize,
                PoolTimeout:     o.PoolTimeout,
                MinIdleConns:    o.MinIdleConns,
                MaxIdleConns:    o.MaxIdleConns,
                MaxActiveConns:  o.MaxActiveConns,
                ConnMaxIdleTime: o.ConnMaxIdleTime,
                ConnMaxLifetime: o.ConnMaxLifetime,

                TLSConfig: o.TLSConfig,

                DisableIdentity:  o.DisableIdentity,
                DisableIndentity: o.DisableIndentity,
                IdentitySuffix:   o.IdentitySuffix,
                UnstableResp3:    o.UnstableResp3,
        }
}

// Failover returns failover options created from the universal options.
func (o *UniversalOptions) Failover() *FailoverOptions {
        if len(o.Addrs) == 0 {
                o.Addrs = []string{"127.0.0.1:26379"}
        }

        return &FailoverOptions{
                SentinelAddrs: o.Addrs,
                MasterName:    o.MasterName,
                ClientName:    o.ClientName,

                Dialer:    o.Dialer,
                OnConnect: o.OnConnect,

                DB:                           o.DB,
                Protocol:                     o.Protocol,
                Username:                     o.Username,
                Password:                     o.Password,
                CredentialsProvider:          o.CredentialsProvider,
                CredentialsProviderContext:   o.CredentialsProviderContext,
                StreamingCredentialsProvider: o.StreamingCredentialsProvider,

                SentinelUsername: o.SentinelUsername,
                SentinelPassword: o.SentinelPassword,

                RouteByLatency: o.RouteByLatency,
                RouteRandomly:  o.RouteRandomly,

                MaxRetries:      o.MaxRetries,
                MinRetryBackoff: o.MinRetryBackoff,
                MaxRetryBackoff: o.MaxRetryBackoff,

                DialTimeout:           o.DialTimeout,
                ReadTimeout:           o.ReadTimeout,
                WriteTimeout:          o.WriteTimeout,
                ContextTimeoutEnabled: o.ContextTimeoutEnabled,

                PoolFIFO:        o.PoolFIFO,
                PoolSize:        o.PoolSize,
                PoolTimeout:     o.PoolTimeout,
                MinIdleConns:    o.MinIdleConns,
                MaxIdleConns:    o.MaxIdleConns,
                MaxActiveConns:  o.MaxActiveConns,
                ConnMaxIdleTime: o.ConnMaxIdleTime,
                ConnMaxLifetime: o.ConnMaxLifetime,

                TLSConfig: o.TLSConfig,

                ReplicaOnly: o.ReadOnly,

                DisableIdentity:  o.DisableIdentity,
                DisableIndentity: o.DisableIndentity,
                IdentitySuffix:   o.IdentitySuffix,
                UnstableResp3:    o.UnstableResp3,
        }
}

// Simple returns basic options created from the universal options.
func (o *UniversalOptions) Simple() *Options {
        addr := "127.0.0.1:6379"
        if len(o.Addrs) > 0 {
                addr = o.Addrs[0]
        }

        return &Options{
                Addr:       addr,
                ClientName: o.ClientName,
                Dialer:     o.Dialer,
                OnConnect:  o.OnConnect,

                DB:                           o.DB,
                Protocol:                     o.Protocol,
                Username:                     o.Username,
                Password:                     o.Password,
                CredentialsProvider:          o.CredentialsProvider,
                CredentialsProviderContext:   o.CredentialsProviderContext,
                StreamingCredentialsProvider: o.StreamingCredentialsProvider,

                MaxRetries:      o.MaxRetries,
                MinRetryBackoff: o.MinRetryBackoff,
                MaxRetryBackoff: o.MaxRetryBackoff,

                DialTimeout:           o.DialTimeout,
                ReadTimeout:           o.ReadTimeout,
                WriteTimeout:          o.WriteTimeout,
                ContextTimeoutEnabled: o.ContextTimeoutEnabled,

                PoolFIFO:        o.PoolFIFO,
                PoolSize:        o.PoolSize,
                PoolTimeout:     o.PoolTimeout,
                MinIdleConns:    o.MinIdleConns,
                MaxIdleConns:    o.MaxIdleConns,
                MaxActiveConns:  o.MaxActiveConns,
                ConnMaxIdleTime: o.ConnMaxIdleTime,
                ConnMaxLifetime: o.ConnMaxLifetime,

                TLSConfig: o.TLSConfig,

                DisableIdentity:  o.DisableIdentity,
                DisableIndentity: o.DisableIndentity,
                IdentitySuffix:   o.IdentitySuffix,
                UnstableResp3:    o.UnstableResp3,
        }
}

// --------------------------------------------------------------------

// UniversalClient is an abstract client which - based on the provided options -
// represents either a ClusterClient, a FailoverClient, or a single-node Client.
// This can be useful for testing cluster-specific applications locally or having different
// clients in different environments.
type UniversalClient interface {
        Cmdable
        AddHook(Hook)
        Watch(ctx context.Context, fn func(*Tx) error, keys ...string) error
        Do(ctx context.Context, args ...interface{}) *Cmd
        Process(ctx context.Context, cmd Cmder) error
        Subscribe(ctx context.Context, channels ...string) *PubSub
        PSubscribe(ctx context.Context, channels ...string) *PubSub
        SSubscribe(ctx context.Context, channels ...string) *PubSub
        Close() error
        PoolStats() *PoolStats
}

var (
        _ UniversalClient = (*Client)(nil)
        _ UniversalClient = (*ClusterClient)(nil)
        _ UniversalClient = (*Ring)(nil)
)

// NewUniversalClient returns a new multi client. The type of the returned client depends
// on the following conditions:
//
//  1. If the MasterName option is specified with RouteByLatency, RouteRandomly or IsClusterMode,
//     a FailoverClusterClient is returned.
//  2. If the MasterName option is specified without RouteByLatency, RouteRandomly or IsClusterMode,
//     a sentinel-backed FailoverClient is returned.
//  3. If the number of Addrs is two or more, or IsClusterMode option is specified,
//     a ClusterClient is returned.
//  4. Otherwise, a single-node Client is returned.
func NewUniversalClient(opts *UniversalOptions) UniversalClient {
        if opts == nil {
                panic("redis: NewUniversalClient nil options")
        }

        switch {
        case opts.MasterName != "" && (opts.RouteByLatency || opts.RouteRandomly || opts.IsClusterMode):
                return NewFailoverClusterClient(opts.Failover())
        case opts.MasterName != "":
                return NewFailoverClient(opts.Failover())
        case len(opts.Addrs) > 1 || opts.IsClusterMode:
                return NewClusterClient(opts.Cluster())
        default:
                return NewClient(opts.Simple())
        }
}

package redis

import (
        "context"
        "encoding/json"
        "strconv"
)

// note: the APIs is experimental and may be subject to change.
type VectorSetCmdable interface {
        VAdd(ctx context.Context, key, element string, val Vector) *BoolCmd
        VAddWithArgs(ctx context.Context, key, element string, val Vector, addArgs *VAddArgs) *BoolCmd
        VCard(ctx context.Context, key string) *IntCmd
        VDim(ctx context.Context, key string) *IntCmd
        VEmb(ctx context.Context, key, element string, raw bool) *SliceCmd
        VGetAttr(ctx context.Context, key, element string) *StringCmd
        VInfo(ctx context.Context, key string) *MapStringInterfaceCmd
        VLinks(ctx context.Context, key, element string) *StringSliceCmd
        VLinksWithScores(ctx context.Context, key, element string) *VectorScoreSliceCmd
        VRandMember(ctx context.Context, key string) *StringCmd
        VRandMemberCount(ctx context.Context, key string, count int) *StringSliceCmd
        VRem(ctx context.Context, key, element string) *BoolCmd
        VSetAttr(ctx context.Context, key, element string, attr interface{}) *BoolCmd
        VClearAttributes(ctx context.Context, key, element string) *BoolCmd
        VSim(ctx context.Context, key string, val Vector) *StringSliceCmd
        VSimWithScores(ctx context.Context, key string, val Vector) *VectorScoreSliceCmd
        VSimWithArgs(ctx context.Context, key string, val Vector, args *VSimArgs) *StringSliceCmd
        VSimWithArgsWithScores(ctx context.Context, key string, val Vector, args *VSimArgs) *VectorScoreSliceCmd
}

type Vector interface {
        Value() []any
}

const (
        vectorFormatFP32   string = "FP32"
        vectorFormatValues string = "Values"
)

type VectorFP32 struct {
        Val []byte
}

func (v *VectorFP32) Value() []any {
        return []any{vectorFormatFP32, v.Val}
}

var _ Vector = (*VectorFP32)(nil)

type VectorValues struct {
        Val []float64
}

func (v *VectorValues) Value() []any {
        res := make([]any, 2+len(v.Val))
        res[0] = vectorFormatValues
        res[1] = len(v.Val)
        for i, v := range v.Val {
                res[2+i] = v
        }
        return res
}

var _ Vector = (*VectorValues)(nil)

type VectorRef struct {
        Name string // the name of the referent vector
}

func (v *VectorRef) Value() []any {
        return []any{"ele", v.Name}
}

var _ Vector = (*VectorRef)(nil)

type VectorScore struct {
        Name  string
        Score float64
}

// `VADD key (FP32 | VALUES num) vector element`
// note: the API is experimental and may be subject to change.
func (c cmdable) VAdd(ctx context.Context, key, element string, val Vector) *BoolCmd {
        return c.VAddWithArgs(ctx, key, element, val, &VAddArgs{})
}

type VAddArgs struct {
        // the REDUCE option must be passed immediately after the key
        Reduce int64
        Cas    bool

        // The NoQuant, Q8 and Bin options are mutually exclusive.
        NoQuant bool
        Q8      bool
        Bin     bool

        EF      int64
        SetAttr string
        M       int64
}

func (v VAddArgs) reduce() int64 {
        return v.Reduce
}

func (v VAddArgs) appendArgs(args []any) []any {
        if v.Cas {
                args = append(args, "cas")
        }

        if v.NoQuant {
                args = append(args, "noquant")
        } else if v.Q8 {
                args = append(args, "q8")
        } else if v.Bin {
                args = append(args, "bin")
        }

        if v.EF > 0 {
                args = append(args, "ef", strconv.FormatInt(v.EF, 10))
        }
        if len(v.SetAttr) > 0 {
                args = append(args, "setattr", v.SetAttr)
        }
        if v.M > 0 {
                args = append(args, "m", strconv.FormatInt(v.M, 10))
        }
        return args
}

// `VADD key [REDUCE dim] (FP32 | VALUES num) vector element [CAS] [NOQUANT | Q8 | BIN] [EF build-exploration-factor] [SETATTR attributes] [M numlinks]`
// note: the API is experimental and may be subject to change.
func (c cmdable) VAddWithArgs(ctx context.Context, key, element string, val Vector, addArgs *VAddArgs) *BoolCmd {
        if addArgs == nil {
                addArgs = &VAddArgs{}
        }
        args := []any{"vadd", key}
        if addArgs.reduce() > 0 {
                args = append(args, "reduce", addArgs.reduce())
        }
        args = append(args, val.Value()...)
        args = append(args, element)
        args = addArgs.appendArgs(args)
        cmd := NewBoolCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// `VCARD key`
// note: the API is experimental and may be subject to change.
func (c cmdable) VCard(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "vcard", key)
        _ = c(ctx, cmd)
        return cmd
}

// `VDIM key`
// note: the API is experimental and may be subject to change.
func (c cmdable) VDim(ctx context.Context, key string) *IntCmd {
        cmd := NewIntCmd(ctx, "vdim", key)
        _ = c(ctx, cmd)
        return cmd
}

// `VEMB key element [RAW]`
// note: the API is experimental and may be subject to change.
func (c cmdable) VEmb(ctx context.Context, key, element string, raw bool) *SliceCmd {
        args := []any{"vemb", key, element}
        if raw {
                args = append(args, "raw")
        }
        cmd := NewSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// `VGETATTR key element`
// note: the API is experimental and may be subject to change.
func (c cmdable) VGetAttr(ctx context.Context, key, element string) *StringCmd {
        cmd := NewStringCmd(ctx, "vgetattr", key, element)
        _ = c(ctx, cmd)
        return cmd
}

// `VINFO key`
// note: the API is experimental and may be subject to change.
func (c cmdable) VInfo(ctx context.Context, key string) *MapStringInterfaceCmd {
        cmd := NewMapStringInterfaceCmd(ctx, "vinfo", key)
        _ = c(ctx, cmd)
        return cmd
}

// `VLINKS key element`
// note: the API is experimental and may be subject to change.
func (c cmdable) VLinks(ctx context.Context, key, element string) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "vlinks", key, element)
        _ = c(ctx, cmd)
        return cmd
}

// `VLINKS key element WITHSCORES`
// note: the API is experimental and may be subject to change.
func (c cmdable) VLinksWithScores(ctx context.Context, key, element string) *VectorScoreSliceCmd {
        cmd := NewVectorInfoSliceCmd(ctx, "vlinks", key, element, "withscores")
        _ = c(ctx, cmd)
        return cmd
}

// `VRANDMEMBER key`
// note: the API is experimental and may be subject to change.
func (c cmdable) VRandMember(ctx context.Context, key string) *StringCmd {
        cmd := NewStringCmd(ctx, "vrandmember", key)
        _ = c(ctx, cmd)
        return cmd
}

// `VRANDMEMBER key [count]`
// note: the API is experimental and may be subject to change.
func (c cmdable) VRandMemberCount(ctx context.Context, key string, count int) *StringSliceCmd {
        cmd := NewStringSliceCmd(ctx, "vrandmember", key, count)
        _ = c(ctx, cmd)
        return cmd
}

// `VREM key element`
// note: the API is experimental and may be subject to change.
func (c cmdable) VRem(ctx context.Context, key, element string) *BoolCmd {
        cmd := NewBoolCmd(ctx, "vrem", key, element)
        _ = c(ctx, cmd)
        return cmd
}

// `VSETATTR key element "{ JSON obj }"`
// The `attr` must be something that can be marshaled to JSON (using encoding/JSON) unless
// the argument is a string or []byte when we assume that it can be passed directly as JSON.
//
// note: the API is experimental and may be subject to change.
func (c cmdable) VSetAttr(ctx context.Context, key, element string, attr interface{}) *BoolCmd {
        var attrStr string
        var err error
        switch v := attr.(type) {
        case string:
                attrStr = v
        case []byte:
                attrStr = string(v)
        default:
                var bytes []byte
                bytes, err = json.Marshal(v)
                if err != nil {
                        // If marshalling fails, create the command and set the error; this command won't be executed.
                        cmd := NewBoolCmd(ctx, "vsetattr", key, element, "")
                        cmd.SetErr(err)
                        return cmd
                }
                attrStr = string(bytes)
        }
        cmd := NewBoolCmd(ctx, "vsetattr", key, element, attrStr)
        _ = c(ctx, cmd)
        return cmd
}

// `VClearAttributes` clear attributes on a vector set element.
// The implementation of `VClearAttributes` is execute command `VSETATTR key element ""`.
// note: the API is experimental and may be subject to change.
func (c cmdable) VClearAttributes(ctx context.Context, key, element string) *BoolCmd {
        cmd := NewBoolCmd(ctx, "vsetattr", key, element, "")
        _ = c(ctx, cmd)
        return cmd
}

// `VSIM key (ELE | FP32 | VALUES num) (vector | element)`
// note: the API is experimental and may be subject to change.
func (c cmdable) VSim(ctx context.Context, key string, val Vector) *StringSliceCmd {
        return c.VSimWithArgs(ctx, key, val, &VSimArgs{})
}

// `VSIM key (ELE | FP32 | VALUES num) (vector | element) WITHSCORES`
// note: the API is experimental and may be subject to change.
func (c cmdable) VSimWithScores(ctx context.Context, key string, val Vector) *VectorScoreSliceCmd {
        return c.VSimWithArgsWithScores(ctx, key, val, &VSimArgs{})
}

type VSimArgs struct {
        Count    int64
        EF       int64
        Filter   string
        FilterEF int64
        Truth    bool
        NoThread bool
        // The `VSim` command in Redis has the option, by the doc in Redis.io don't have.
        // Epsilon float64
}

func (v VSimArgs) appendArgs(args []any) []any {
        if v.Count > 0 {
                args = append(args, "count", v.Count)
        }
        if v.EF > 0 {
                args = append(args, "ef", v.EF)
        }
        if len(v.Filter) > 0 {
                args = append(args, "filter", v.Filter)
        }
        if v.FilterEF > 0 {
                args = append(args, "filter-ef", v.FilterEF)
        }
        if v.Truth {
                args = append(args, "truth")
        }
        if v.NoThread {
                args = append(args, "nothread")
        }
        // if v.Epsilon > 0 {
        //        args = append(args, "Epsilon", v.Epsilon)
        // }
        return args
}

// `VSIM key (ELE | FP32 | VALUES num) (vector | element) [COUNT num]
// [EF search-exploration-factor] [FILTER expression] [FILTER-EF max-filtering-effort] [TRUTH] [NOTHREAD]`
// note: the API is experimental and may be subject to change.
func (c cmdable) VSimWithArgs(ctx context.Context, key string, val Vector, simArgs *VSimArgs) *StringSliceCmd {
        if simArgs == nil {
                simArgs = &VSimArgs{}
        }
        args := []any{"vsim", key}
        args = append(args, val.Value()...)
        args = simArgs.appendArgs(args)
        cmd := NewStringSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

// `VSIM key (ELE | FP32 | VALUES num) (vector | element) [WITHSCORES] [COUNT num]
// [EF search-exploration-factor] [FILTER expression] [FILTER-EF max-filtering-effort] [TRUTH] [NOTHREAD]`
// note: the API is experimental and may be subject to change.
func (c cmdable) VSimWithArgsWithScores(ctx context.Context, key string, val Vector, simArgs *VSimArgs) *VectorScoreSliceCmd {
        if simArgs == nil {
                simArgs = &VSimArgs{}
        }
        args := []any{"vsim", key}
        args = append(args, val.Value()...)
        args = append(args, "withscores")
        args = simArgs.appendArgs(args)
        cmd := NewVectorInfoSliceCmd(ctx, args...)
        _ = c(ctx, cmd)
        return cmd
}

package redis

// Version is the current release version.
func Version() string {
        return "9.11.0"
}