package db

import (
	"context"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/redis/go-redis/v9"
)

func redisDBIndex(c ConnReq) int {
	db := 0
	if c.Database != "" {
		if n, err := strconv.Atoi(c.Database); err == nil {
			db = n
		}
	}
	return db
}

func normalizeRedisMode(c ConnReq) string {
	m := strings.ToLower(strings.TrimSpace(c.RedisMode))
	if m == "" {
		return "standalone"
	}
	return m
}

// parseRedisAddrs 解析 host:port 列表（换行 / 逗号 / 分号 / 空白分隔）。
func parseRedisAddrs(raw string) []string {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return nil
	}
	raw = strings.ReplaceAll(raw, "\r\n", "\n")
	raw = strings.ReplaceAll(raw, "\r", "\n")
	raw = strings.ReplaceAll(raw, ",", " ")
	raw = strings.ReplaceAll(raw, ";", " ")
	raw = strings.ReplaceAll(raw, "\n", " ")
	parts := strings.Fields(raw)
	out := make([]string, 0, len(parts))
	seen := map[string]struct{}{}
	for _, p := range parts {
		p = strings.TrimSpace(p)
		if p == "" {
			continue
		}
		if _, ok := seen[p]; ok {
			continue
		}
		seen[p] = struct{}{}
		out = append(out, p)
	}
	return out
}

func redisStandaloneOpts(c ConnReq) (*redis.Options, error) {
	host := c.Host
	if host == "" {
		host = "127.0.0.1"
	}
	port := c.Port
	if port == 0 {
		port = 6379
	}
	opts := &redis.Options{
		Addr:         fmt.Sprintf("%s:%d", host, port),
		Password:     c.Password,
		Username:     c.User,
		DB:           redisDBIndex(c),
		DialTimeout:  5 * time.Second,
		ReadTimeout:  10 * time.Second,
		WriteTimeout: 10 * time.Second,
	}
	if SSLEnabled(c) {
		tlsCfg, err := tlsConfigFrom(c)
		if err != nil {
			return nil, err
		}
		opts.TLSConfig = tlsCfg
	}
	return opts, nil
}

// openRedis 按 redisMode 建 UniversalClient（单机 / Sentinel / Cluster）。
func openRedis(c ConnReq) (redis.UniversalClient, error) {
	mode := normalizeRedisMode(c)
	switch mode {
	case "sentinel":
		addrs := parseRedisAddrs(c.RedisNodes)
		if len(addrs) == 0 {
			return nil, fmt.Errorf("Sentinel 模式请填写至少一个 Sentinel 节点（host:port）")
		}
		master := strings.TrimSpace(c.MasterName)
		if master == "" {
			return nil, fmt.Errorf("Sentinel 模式请填写主节点名 masterName")
		}
		opts := &redis.FailoverOptions{
			MasterName:       master,
			SentinelAddrs:    addrs,
			Password:         c.Password,
			Username:         c.User,
			SentinelPassword: c.SentinelPassword,
			DB:               redisDBIndex(c),
			DialTimeout:      5 * time.Second,
			ReadTimeout:      10 * time.Second,
			WriteTimeout:     10 * time.Second,
		}
		if SSLEnabled(c) {
			tlsCfg, err := tlsConfigFrom(c)
			if err != nil {
				return nil, err
			}
			opts.TLSConfig = tlsCfg
		}
		return redis.NewFailoverClient(opts), nil
	case "cluster":
		addrs := parseRedisAddrs(c.RedisNodes)
		if len(addrs) == 0 {
			return nil, fmt.Errorf("Cluster 模式请填写至少一个种子节点（host:port）")
		}
		opts := &redis.ClusterOptions{
			Addrs:        addrs,
			Password:     c.Password,
			Username:     c.User,
			DialTimeout:  5 * time.Second,
			ReadTimeout:  10 * time.Second,
			WriteTimeout: 10 * time.Second,
		}
		if SSLEnabled(c) {
			tlsCfg, err := tlsConfigFrom(c)
			if err != nil {
				return nil, err
			}
			opts.TLSConfig = tlsCfg
		}
		return redis.NewClusterClient(opts), nil
	default:
		opts, err := redisStandaloneOpts(c)
		if err != nil {
			return nil, err
		}
		return redis.NewClient(opts), nil
	}
}

// redisClientFor:会话请求复用会话级单例,非会话请求新建并随请求关闭。
func redisClientFor(c ConnReq) (cli redis.UniversalClient, done func(), err error) {
	if c.SessionID != "" {
		s, err := GetSession(c.SessionID)
		if err != nil {
			return nil, nil, err
		}
		// 请求携带的 Database 决定用哪个 DB 的客户端（对象树切库时逐请求变化）
		cli, err := s.redisClientFor(c)
		if err != nil {
			return nil, nil, err
		}
		return cli, func() {}, nil
	}
	cli, err = openRedis(c)
	if err != nil {
		return nil, nil, err
	}
	return cli, func() { _ = cli.Close() }, nil
}

func reqCtxRedis(parent context.Context, d time.Duration) (context.Context, context.CancelFunc) {
	if parent == nil {
		parent = context.Background()
	}
	return context.WithTimeout(parent, d)
}

func testRedis(c ConnReq) error {
	cli, err := openRedis(c)
	if err != nil {
		return err
	}
	defer cli.Close()
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	return cli.Ping(ctx).Err()
}

func listDatabasesRedis(parent context.Context, c ConnReq) ([]string, error) {
	// INFO keyspace 可拿已用 DB；统一暴露 0-15 便于切换,先 Ping 探活
	cli, done, err := redisClientFor(c)
	if err != nil {
		return nil, err
	}
	defer done()
	ctx, cancel := reqCtxRedis(parent, 5*time.Second)
	defer cancel()
	if err := cli.Ping(ctx).Err(); err != nil {
		return nil, err
	}
	// Cluster 不支持 SELECT 多库，只暴露 0
	if normalizeRedisMode(c) == "cluster" {
		return []string{"0"}, nil
	}
	out := make([]string, 16)
	for i := 0; i < 16; i++ {
		out[i] = strconv.Itoa(i)
	}
	return out, nil
}

func listTablesRedis(parent context.Context, c ConnReq) ([]string, error) {
	cli, done, err := redisClientFor(c)
	if err != nil {
		return nil, err
	}
	defer done()
	ctx, cancel := reqCtxRedis(parent, 8*time.Second)
	defer cancel()
	var keys []string
	var cursor uint64
	for {
		batch, next, err := cli.Scan(ctx, cursor, "*", 200).Result()
		if err != nil {
			return nil, err
		}
		keys = append(keys, batch...)
		cursor = next
		if cursor == 0 || len(keys) >= 500 {
			break
		}
	}
	if keys == nil {
		keys = []string{}
	}
	return keys, nil
}

// redisDangerCmds 需要 confirmDanger 确认后才执行的命令组:
// FLUSHALL/FLUSHDB/CONFIG 破坏性;KEYS 大库阻塞。
var redisDangerCmds = map[string]bool{
	"FLUSHALL": true,
	"FLUSHDB":  true,
	"CONFIG":   true,
	"KEYS":     true,
}

func redisOK(start time.Time) ExecResult {
	return ExecResult{
		Columns:  []string{"affected_rows"},
		Rows:     []map[string]interface{}{{"affected_rows": 1}},
		RowCount: 1,
		TimeMs:   time.Since(start).Milliseconds(),
	}
}

func redisAffected(start time.Time, n int64) ExecResult {
	return ExecResult{
		Columns:  []string{"affected_rows"},
		Rows:     []map[string]interface{}{{"affected_rows": n}},
		RowCount: 1,
		TimeMs:   time.Since(start).Milliseconds(),
	}
}

func redisErr(start time.Time, err error) ExecResult {
	return ExecResult{Error: errMsg(err), TimeMs: time.Since(start).Milliseconds()}
}

func redisUsage(start time.Time, usage string) ExecResult {
	return ExecResult{Error: usage, TimeMs: time.Since(start).Milliseconds()}
}

func execRedis(parent context.Context, c ConnReq) ExecResult {
	start := time.Now()
	sql := strings.TrimSpace(c.SQL)
	if sql == "" {
		return ExecResult{Error: "empty sql", TimeMs: 0}
	}
	fields := splitRedisCmd(sql)
	if len(fields) == 0 {
		return ExecResult{Error: "empty command", TimeMs: time.Since(start).Milliseconds()}
	}
	cmd := strings.ToUpper(fields[0])
	args := fields[1:]

	// 危险命令二段确认:未确认不执行
	if redisDangerCmds[cmd] && !c.ConfirmDanger {
		return ExecResult{
			Error:       "检测到危险命令: " + cmd,
			NeedConfirm: true,
			TimeMs:      time.Since(start).Milliseconds(),
		}
	}

	cli, done, err := redisClientFor(c)
	if err != nil {
		return redisErr(start, err)
	}
	defer done()
	ctx, cancel := reqCtxRedis(parent, 10*time.Second)
	defer cancel()

	switch cmd {
	case "PING":
		val, err := cli.Ping(ctx).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return ExecResult{Columns: []string{"result"}, Rows: []map[string]interface{}{{"result": val}}, RowCount: 1, TimeMs: time.Since(start).Milliseconds()}
	case "GET":
		if len(args) < 1 {
			return redisUsage(start, "GET key")
		}
		val, err := cli.Get(ctx, args[0]).Result()
		if err == redis.Nil {
			return ExecResult{Columns: []string{"key", "value"}, Rows: []map[string]interface{}{}, RowCount: 0, TimeMs: time.Since(start).Milliseconds()}
		}
		if err != nil {
			return redisErr(start, err)
		}
		return ExecResult{Columns: []string{"key", "value"}, Rows: []map[string]interface{}{{"key": args[0], "value": val}}, RowCount: 1, TimeMs: time.Since(start).Milliseconds()}
	case "SET":
		// 参数已按 shell 词法切分,value 即 args[1](不再 Join 破坏引号分组);
		// 支持可选 EX 秒数:SET key value [EX n]
		if len(args) < 2 {
			return redisUsage(start, "SET key value [EX seconds]")
		}
		exp := time.Duration(0)
		if len(args) >= 4 && strings.ToUpper(args[2]) == "EX" {
			n, err := strconv.Atoi(args[3])
			if err != nil || n <= 0 {
				return redisUsage(start, "SET key value EX seconds(秒数需为正整数)")
			}
			exp = time.Duration(n) * time.Second
		}
		if err := cli.Set(ctx, args[0], args[1], exp).Err(); err != nil {
			return redisErr(start, err)
		}
		return redisOK(start)
	case "DEL":
		if len(args) < 1 {
			return redisUsage(start, "DEL key [key...]")
		}
		n, err := cli.Del(ctx, args...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return redisAffected(start, n)
	case "KEYS":
		// 危险组已在上面对 confirmDanger 把关,此处直接执行
		pat := "*"
		if len(args) > 0 {
			pat = args[0]
		}
		keys, err := cli.Keys(ctx, pat).Result()
		if err != nil {
			return redisErr(start, err)
		}
		rows := make([]map[string]interface{}, 0, len(keys))
		for _, k := range keys {
			rows = append(rows, map[string]interface{}{"key": k})
		}
		return ExecResult{Columns: []string{"key"}, Rows: rows, RowCount: len(rows), TimeMs: time.Since(start).Milliseconds()}
	case "FLUSHALL", "FLUSHDB":
		// 危险组,已经过 confirmDanger 把关
		var err error
		if cmd == "FLUSHALL" {
			err = cli.FlushAll(ctx).Err()
		} else {
			err = cli.FlushDB(ctx).Err()
		}
		if err != nil {
			return redisErr(start, err)
		}
		return redisOK(start)
	case "CONFIG":
		// 危险组,已经过 confirmDanger 把关;通用透传(CONFIG GET/SET ...)
		if len(args) < 1 {
			return redisUsage(start, "CONFIG GET|SET parameter [value]")
		}
		doArgs := append([]interface{}{"CONFIG"}, strsToAnys(args)...)
		val, err := cli.Do(ctx, doArgs...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return ExecResult{Columns: []string{"result"}, Rows: []map[string]interface{}{{"result": normalize(fmt.Sprintf("%v", val))}}, RowCount: 1, TimeMs: time.Since(start).Milliseconds()}
	case "SCAN":
		pat := "*"
		count := int64(200)
		i := 0
		if len(args) > 0 {
			// SCAN cursor [MATCH pattern] [COUNT n] —— 忽略 cursor，内部自扫
			i = 1
		}
		for i < len(args) {
			up := strings.ToUpper(args[i])
			if up == "MATCH" && i+1 < len(args) {
				pat = args[i+1]
				i += 2
				continue
			}
			if up == "COUNT" && i+1 < len(args) {
				if n, err := strconv.ParseInt(args[i+1], 10, 64); err == nil && n > 0 {
					count = n
				}
				i += 2
				continue
			}
			i++
		}
		names, truncated, err := scanAll(ctx, cli, pat, count, redisKeyListCap)
		if err != nil {
			return redisErr(start, err)
		}
		if names == nil {
			names = []string{}
		}
		rows := make([]map[string]interface{}, 0, len(names))
		for _, k := range names {
			rows = append(rows, map[string]interface{}{"key": k})
		}
		return ExecResult{Columns: []string{"key"}, Rows: rows, RowCount: len(rows), TimeMs: time.Since(start).Milliseconds(), Truncated: truncated}
	case "EXPIRE":
		if len(args) < 2 {
			return redisUsage(start, "EXPIRE key seconds")
		}
		sec, err := strconv.Atoi(args[1])
		if err != nil {
			return redisUsage(start, "EXPIRE key seconds(秒数需为整数)")
		}
		ok, err := cli.Expire(ctx, args[0], time.Duration(sec)*time.Second).Result()
		if err != nil {
			return redisErr(start, err)
		}
		if !ok {
			return redisAffected(start, 0)
		}
		return redisAffected(start, 1)
	case "PERSIST":
		if len(args) < 1 {
			return redisUsage(start, "PERSIST key")
		}
		ok, err := cli.Persist(ctx, args[0]).Result()
		if err != nil {
			return redisErr(start, err)
		}
		if !ok {
			return redisAffected(start, 0)
		}
		return redisAffected(start, 1)
	case "HSET":
		if len(args) < 3 || len(args)%2 == 0 {
			return redisUsage(start, "HSET key field value [field value...]")
		}
		n, err := cli.HSet(ctx, args[0], strsToAnys(args[1:])...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return redisAffected(start, n)
	case "HDEL":
		if len(args) < 2 {
			return redisUsage(start, "HDEL key field [field...]")
		}
		n, err := cli.HDel(ctx, args[0], args[1:]...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return redisAffected(start, n)
	case "SADD":
		if len(args) < 2 {
			return redisUsage(start, "SADD key member [member...]")
		}
		n, err := cli.SAdd(ctx, args[0], strsToAnys(args[1:])...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return redisAffected(start, n)
	case "SREM":
		if len(args) < 2 {
			return redisUsage(start, "SREM key member [member...]")
		}
		n, err := cli.SRem(ctx, args[0], strsToAnys(args[1:])...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return redisAffected(start, n)
	case "ZADD":
		// ZADD key score member [score member...]
		if len(args) < 3 || len(args)%2 == 0 {
			return redisUsage(start, "ZADD key score member [score member...]")
		}
		var zs []redis.Z
		for i := 1; i+1 < len(args); i += 2 {
			score, err := strconv.ParseFloat(args[i], 64)
			if err != nil {
				return redisUsage(start, "ZADD score 需为数字: "+args[i])
			}
			zs = append(zs, redis.Z{Score: score, Member: args[i+1]})
		}
		n, err := cli.ZAdd(ctx, args[0], zs...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return redisAffected(start, n)
	case "ZREM":
		if len(args) < 2 {
			return redisUsage(start, "ZREM key member [member...]")
		}
		n, err := cli.ZRem(ctx, args[0], strsToAnys(args[1:])...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return redisAffected(start, n)
	case "LPUSH", "RPUSH":
		if len(args) < 2 {
			return redisUsage(start, cmd+" key value [value...]")
		}
		var n int64
		var err error
		if cmd == "LPUSH" {
			n, err = cli.LPush(ctx, args[0], strsToAnys(args[1:])...).Result()
		} else {
			n, err = cli.RPush(ctx, args[0], strsToAnys(args[1:])...).Result()
		}
		if err != nil {
			return redisErr(start, err)
		}
		return redisAffected(start, n)
	case "LSET":
		if len(args) < 3 {
			return redisUsage(start, "LSET key index value")
		}
		idx, err := strconv.ParseInt(args[1], 10, 64)
		if err != nil {
			return redisUsage(start, "LSET key index value(index 需为整数)")
		}
		if err := cli.LSet(ctx, args[0], idx, args[2]).Err(); err != nil {
			return redisErr(start, err)
		}
		return redisOK(start)
	case "INCR", "DECR":
		if len(args) < 1 {
			return redisUsage(start, cmd+" key")
		}
		var n int64
		var err error
		if cmd == "INCR" {
			n, err = cli.Incr(ctx, args[0]).Result()
		} else {
			n, err = cli.Decr(ctx, args[0]).Result()
		}
		if err != nil {
			return redisErr(start, err)
		}
		return ExecResult{Columns: []string{"value"}, Rows: []map[string]interface{}{{"value": n}}, RowCount: 1, TimeMs: time.Since(start).Milliseconds()}
	case "MGET":
		if len(args) < 1 {
			return redisUsage(start, "MGET key [key...]")
		}
		vals, err := cli.MGet(ctx, args...).Result()
		if err != nil {
			return redisErr(start, err)
		}
		rows := make([]map[string]interface{}, 0, len(args))
		for i, v := range vals {
			rows = append(rows, map[string]interface{}{"key": args[i], "value": normalize(v)})
		}
		return ExecResult{Columns: []string{"key", "value"}, Rows: rows, RowCount: len(rows), TimeMs: time.Since(start).Milliseconds()}
	case "MSET":
		if len(args) < 2 || len(args)%2 != 0 {
			return redisUsage(start, "MSET key value [key value...]")
		}
		if err := cli.MSet(ctx, strsToAnys(args)...).Err(); err != nil {
			return redisErr(start, err)
		}
		return redisOK(start)
	case "RENAME":
		if len(args) < 2 {
			return redisUsage(start, "RENAME key newkey")
		}
		if err := cli.Rename(ctx, args[0], args[1]).Err(); err != nil {
			return redisErr(start, err)
		}
		return redisOK(start)
	case "HGETALL":
		if len(args) < 1 {
			return redisUsage(start, "HGETALL key")
		}
		c2 := c
		c2.Key = args[0]
		c2.Limit = redisValueRowCap
		v := GetRedisKey(ctx, c2)
		if v.Error != "" && v.Type == "" {
			return ExecResult{Error: v.Error, TimeMs: time.Since(start).Milliseconds()}
		}
		return ExecResult{Columns: v.Columns, Rows: v.Rows, RowCount: v.RowCount, TimeMs: time.Since(start).Milliseconds(), Truncated: v.Truncated, Limit: v.Limit, NextCursor: v.NextCursor, Error: v.Error}
	case "LRANGE":
		if len(args) < 1 {
			return redisUsage(start, "LRANGE key [start stop]")
		}
		c2 := c
		c2.Key = args[0]
		c2.Limit = redisValueRowCap
		v := GetRedisKey(ctx, c2)
		return ExecResult{Columns: v.Columns, Rows: v.Rows, RowCount: v.RowCount, TimeMs: time.Since(start).Milliseconds(), Truncated: v.Truncated, Limit: v.Limit, NextCursor: v.NextCursor, Error: v.Error}
	case "SMEMBERS":
		if len(args) < 1 {
			return redisUsage(start, "SMEMBERS key")
		}
		c2 := c
		c2.Key = args[0]
		v := GetRedisKey(ctx, c2)
		return ExecResult{Columns: v.Columns, Rows: v.Rows, RowCount: v.RowCount, TimeMs: time.Since(start).Milliseconds(), Truncated: v.Truncated, Limit: v.Limit, NextCursor: v.NextCursor, Error: v.Error}
	case "ZRANGE":
		if len(args) < 1 {
			return redisUsage(start, "ZRANGE key [start stop]")
		}
		c2 := c
		c2.Key = args[0]
		v := GetRedisKey(ctx, c2)
		return ExecResult{Columns: v.Columns, Rows: v.Rows, RowCount: v.RowCount, TimeMs: time.Since(start).Milliseconds(), Truncated: v.Truncated, Limit: v.Limit, NextCursor: v.NextCursor, Error: v.Error}
	case "TYPE":
		if len(args) < 1 {
			return redisUsage(start, "TYPE key")
		}
		t, err := cli.Type(ctx, args[0]).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return ExecResult{Columns: []string{"key", "type"}, Rows: []map[string]interface{}{{"key": args[0], "type": t}}, RowCount: 1, TimeMs: time.Since(start).Milliseconds()}
	case "TTL":
		if len(args) < 1 {
			return redisUsage(start, "TTL key")
		}
		n, err := cli.TTL(ctx, args[0]).Result()
		if err != nil {
			return redisErr(start, err)
		}
		return ExecResult{Columns: []string{"key", "ttl_sec"}, Rows: []map[string]interface{}{{"key": args[0], "ttl_sec": int64(n.Seconds())}}, RowCount: 1, TimeMs: time.Since(start).Milliseconds()}
	default:
		// 未点名的命令走通用 Do，避免 CLI 只能跑白名单。
		doArgs := append([]interface{}{cmd}, strsToAnys(args)...)
		val, err := cli.Do(ctx, doArgs...).Result()
		if err == redis.Nil {
			return ExecResult{
				Columns:  []string{"result"},
				Rows:     []map[string]interface{}{{"result": "(nil)"}},
				RowCount: 1,
				TimeMs:   time.Since(start).Milliseconds(),
			}
		}
		if err != nil {
			return redisErr(start, err)
		}
		return formatRedisReply(start, val)
	}
}

func formatRedisReply(start time.Time, val interface{}) ExecResult {
	ms := time.Since(start).Milliseconds()
	switch v := val.(type) {
	case nil:
		return ExecResult{Columns: []string{"result"}, Rows: []map[string]interface{}{{"result": "(nil)"}}, RowCount: 1, TimeMs: ms}
	case string:
		return ExecResult{Columns: []string{"result"}, Rows: []map[string]interface{}{{"result": v}}, RowCount: 1, TimeMs: ms}
	case []byte:
		return formatRedisReply(start, string(v))
	case int64:
		return ExecResult{Columns: []string{"result"}, Rows: []map[string]interface{}{{"result": v}}, RowCount: 1, TimeMs: ms}
	case float64:
		return ExecResult{Columns: []string{"result"}, Rows: []map[string]interface{}{{"result": v}}, RowCount: 1, TimeMs: ms}
	case bool:
		return ExecResult{Columns: []string{"result"}, Rows: []map[string]interface{}{{"result": v}}, RowCount: 1, TimeMs: ms}
	case error:
		return ExecResult{Error: v.Error(), TimeMs: ms}
	case []interface{}:
		if len(v) == 0 {
			return ExecResult{Columns: []string{"value"}, Rows: []map[string]interface{}{}, RowCount: 0, TimeMs: ms}
		}
		if kvRows := redisPairRows(v); kvRows != nil {
			return ExecResult{Columns: []string{"field", "value"}, Rows: kvRows, RowCount: len(kvRows), TimeMs: ms}
		}
		rows := make([]map[string]interface{}, 0, len(v))
		for i, item := range v {
			rows = append(rows, map[string]interface{}{"index": i, "value": normalizeRedisReply(item)})
		}
		return ExecResult{Columns: []string{"index", "value"}, Rows: rows, RowCount: len(rows), TimeMs: ms}
	case map[string]interface{}:
		keys := make([]string, 0, len(v))
		for k := range v {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		rows := make([]map[string]interface{}, 0, len(keys))
		for _, k := range keys {
			rows = append(rows, map[string]interface{}{"field": k, "value": normalizeRedisReply(v[k])})
		}
		return ExecResult{Columns: []string{"field", "value"}, Rows: rows, RowCount: len(rows), TimeMs: ms}
	default:
		return ExecResult{Columns: []string{"result"}, Rows: []map[string]interface{}{{"result": normalizeRedisReply(v)}}, RowCount: 1, TimeMs: ms}
	}
}

func redisPairRows(v []interface{}) []map[string]interface{} {
	if len(v) < 2 || len(v)%2 != 0 {
		return nil
	}
	for _, item := range v {
		switch item.(type) {
		case string, []byte:
		default:
			return nil
		}
	}
	rows := make([]map[string]interface{}, 0, len(v)/2)
	for i := 0; i+1 < len(v); i += 2 {
		rows = append(rows, map[string]interface{}{
			"field": normalizeRedisReply(v[i]),
			"value": normalizeRedisReply(v[i+1]),
		})
	}
	return rows
}

func normalizeRedisReply(v interface{}) interface{} {
	switch t := v.(type) {
	case nil:
		return "(nil)"
	case []byte:
		return string(t)
	case []interface{}:
		parts := make([]string, len(t))
		for i, x := range t {
			parts[i] = fmt.Sprintf("%v", normalizeRedisReply(x))
		}
		return strings.Join(parts, " ")
	default:
		return normalize(t)
	}
}

func strsToAnys(ss []string) []interface{} {
	out := make([]interface{}, len(ss))
	for i, s := range ss {
		out[i] = s
	}
	return out
}

// splitRedisCmd 按 shell 词法切分:空格分隔,单/双引号分组,反斜杠转义。
func splitRedisCmd(s string) []string {
	var out []string
	var cur strings.Builder
	inS, inD := false, false
	esc := false
	for _, r := range s {
		switch {
		case esc:
			cur.WriteRune(r)
			esc = false
		case r == '\\':
			esc = true
		case r == '"' && !inS:
			inD = !inD
		case r == '\'' && !inD:
			inS = !inS
		case !inS && !inD && (r == ' ' || r == '\t' || r == '\n'):
			if cur.Len() > 0 {
				out = append(out, cur.String())
				cur.Reset()
			}
		default:
			cur.WriteRune(r)
		}
	}
	if cur.Len() > 0 {
		out = append(out, cur.String())
	}
	return out
}

func isRedis(d string) bool {
	return driverKey(d) == "redis"
}

// IsRedisDriver exported for router guards.
func IsRedisDriver(d string) bool {
	return isRedis(d)
}

func listColumnsRedis(parent context.Context, c ConnReq, key string) ([]ColumnInfo, error) {
	cli, done, err := redisClientFor(c)
	if err != nil {
		return nil, err
	}
	defer done()
	ctx, cancel := reqCtxRedis(parent, 5*time.Second)
	defer cancel()
	typ, err := cli.Type(ctx, key).Result()
	if err != nil {
		return nil, err
	}
	ttl, _ := cli.TTL(ctx, key).Result()
	return []ColumnInfo{
		{Name: key, Type: typ, Comment: fmt.Sprintf("ttl=%ds", int64(ttl.Seconds()))},
	}, nil
}

const redisKeyListCap = 500
const redisValueRowCap = 500

func redisKeyName(c ConnReq) string {
	if c.Key != "" {
		return c.Key
	}
	return c.Table
}

func redisScanPattern(c ConnReq) string {
	p := strings.TrimSpace(c.Pattern)
	if p == "" {
		return "*"
	}
	return p
}

func redisValueLimit(c ConnReq) int {
	n := c.Limit
	if n <= 0 {
		n = redisValueRowCap
	}
	if n > MaxRowLimit {
		n = MaxRowLimit
	}
	return n
}

func ttlSeconds(d time.Duration) int64 {
	// go-redis maps Redis TTL -1 (no expire) / -2 (missing) to -1ns/-2ns
	// (some versions use -1s/-2s). Truncating with d/time.Second turns those into 0.
	switch d {
	case time.Duration(-1), -1 * time.Second:
		return -1
	case time.Duration(-2), -2 * time.Second:
		return -2
	}
	return int64(d / time.Second)
}

// scanAll 全量 SCAN 到 limit 截断。集群模式遍历所有 master 分片 ——
// ClusterClient.Scan 只命中单个节点，会漏掉其他分片的键。
func scanAll(ctx context.Context, cli redis.UniversalClient, pat string, count int64, limit int) (names []string, truncated bool, err error) {
	scanOne := func(c scanClient) error {
		var cursor uint64
		for {
			batch, next, err := c.Scan(ctx, cursor, pat, count).Result()
			if err != nil {
				return err
			}
			names = append(names, batch...)
			cursor = next
			if len(names) >= limit {
				truncated = true
				return nil
			}
			if cursor == 0 {
				return nil
			}
		}
	}
	if cc, ok := cli.(*redis.ClusterClient); ok {
		err = cc.ForEachMaster(ctx, func(ctx context.Context, mc *redis.Client) error {
			return scanOne(mc)
		})
		if err == nil {
			// 跨分片归并排序，保证键树稳定
			sort.Strings(names)
			if len(names) > limit {
				names = names[:limit]
			}
		}
		return names, truncated, err
	}
	err = scanOne(cli)
	return names, truncated, err
}

// scanClient Scan 的最小接口（*redis.Client 与 UniversalClient 都满足）
type scanClient interface {
	Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd
}

// ListRedisKeys SCAN + pipeline TYPE/TTL. Cap ~500.
func ListRedisKeys(parent context.Context, c ConnReq) RedisKeysResult {
	start := time.Now()
	cli, done, err := redisClientFor(c)
	if err != nil {
		return RedisKeysResult{Keys: []RedisKeyInfo{}, Error: errMsg(err), TimeMs: time.Since(start).Milliseconds()}
	}
	defer done()
	ctx, cancel := reqCtxRedis(parent, 12*time.Second)
	defer cancel()

	pat := redisScanPattern(c)
	names, truncated, err := scanAll(ctx, cli, pat, 200, redisKeyListCap)
	if err != nil {
		return RedisKeysResult{Keys: []RedisKeyInfo{}, Error: errMsg(err), TimeMs: time.Since(start).Milliseconds()}
	}
	if names == nil {
		names = []string{}
	}

	out := make([]RedisKeyInfo, len(names))
	if len(names) == 0 {
		return RedisKeysResult{Keys: out, Truncated: truncated, TimeMs: time.Since(start).Milliseconds()}
	}

	// Pipeline TYPE + TTL (avoid N+1)
	pipe := cli.Pipeline()
	typeCmds := make([]*redis.StatusCmd, len(names))
	ttlCmds := make([]*redis.DurationCmd, len(names))
	for i, k := range names {
		typeCmds[i] = pipe.Type(ctx, k)
		ttlCmds[i] = pipe.TTL(ctx, k)
	}
	_, _ = pipe.Exec(ctx)
	for i, k := range names {
		typ := "none"
		if t, err := typeCmds[i].Result(); err == nil {
			typ = t
		}
		ttl := int64(-2)
		if d, err := ttlCmds[i].Result(); err == nil {
			ttl = ttlSeconds(d)
		}
		out[i] = RedisKeyInfo{Name: k, Type: typ, TTL: ttl}
	}
	return RedisKeysResult{Keys: out, Truncated: truncated, TimeMs: time.Since(start).Milliseconds()}
}

// GetRedisKey typed value → ResultPane columns/rows.
func GetRedisKey(parent context.Context, c ConnReq) RedisKeyValue {
	start := time.Now()
	key := redisKeyName(c)
	if key == "" {
		return RedisKeyValue{Error: "缺少 key", TimeMs: time.Since(start).Milliseconds()}
	}
	cli, done, err := redisClientFor(c)
	if err != nil {
		return RedisKeyValue{Name: key, Error: errMsg(err), TimeMs: time.Since(start).Milliseconds()}
	}
	defer done()
	ctx, cancel := reqCtxRedis(parent, 10*time.Second)
	defer cancel()

	typ, err := cli.Type(ctx, key).Result()
	if err != nil {
		return RedisKeyValue{Name: key, Error: errMsg(err), TimeMs: time.Since(start).Milliseconds()}
	}
	ttl := int64(-2)
	if d, err := cli.TTL(ctx, key).Result(); err == nil {
		ttl = ttlSeconds(d)
	}
	limit := redisValueLimit(c)
	base := RedisKeyValue{Name: key, Type: typ, TTL: ttl, Limit: limit}

	switch typ {
	case "none":
		base.Columns = []string{"value"}
		base.Rows = []map[string]interface{}{}
		base.RowCount = 0
		base.Error = "key 不存在"
		base.TimeMs = time.Since(start).Milliseconds()
		return base
	case "string":
		val, err := cli.Get(ctx, key).Result()
		if err == redis.Nil {
			base.Columns = []string{"value"}
			base.Rows = []map[string]interface{}{}
			base.RowCount = 0
			base.TimeMs = time.Since(start).Milliseconds()
			return base
		}
		if err != nil {
			base.Error = errMsg(err)
			base.TimeMs = time.Since(start).Milliseconds()
			return base
		}
		base.Columns = []string{"value"}
		base.Rows = []map[string]interface{}{{"value": val}}
		base.RowCount = 1
		base.TimeMs = time.Since(start).Milliseconds()
		return base
	case "hash":
		// HSCAN 游标分页：cursor 回传续载（0=起点/到底），页内按 field 排序保持观感
		pairs, next, err := cli.HScan(ctx, key, uint64(c.Cursor), "*", int64(limit)).Result()
		if err != nil {
			base.Error = errMsg(err)
			base.TimeMs = time.Since(start).Milliseconds()
			return base
		}
		base.Columns = []string{"field", "value"}
		rows := make([]map[string]interface{}, 0, len(pairs)/2)
		for i := 0; i+1 < len(pairs); i += 2 {
			rows = append(rows, map[string]interface{}{"field": pairs[i], "value": pairs[i+1]})
		}
		sort.Slice(rows, func(i, j int) bool { return fmt.Sprint(rows[i]["field"]) < fmt.Sprint(rows[j]["field"]) })
		base.Rows = rows
		base.RowCount = len(rows)
		base.NextCursor = int64(next)
		base.Truncated = next != 0
		base.TimeMs = time.Since(start).Milliseconds()
		return base
	case "list":
		// 偏移分页：cursor = 起始下标
		offset := c.Cursor
		if offset < 0 {
			offset = 0
		}
		vals, err := cli.LRange(ctx, key, offset, offset+int64(limit)-1).Result()
		if err != nil {
			base.Error = errMsg(err)
			base.TimeMs = time.Since(start).Milliseconds()
			return base
		}
		n, _ := cli.LLen(ctx, key).Result()
		base.Columns = []string{"index", "value"}
		rows := make([]map[string]interface{}, 0, len(vals))
		for i, v := range vals {
			rows = append(rows, map[string]interface{}{"index": offset + int64(i), "value": v})
		}
		base.Rows = rows
		base.RowCount = len(rows)
		if offset+int64(len(vals)) < n {
			base.NextCursor = offset + int64(len(vals))
			base.Truncated = true
		}
		base.TimeMs = time.Since(start).Milliseconds()
		return base
	case "set":
		// SSCAN 游标分页：每页 limit，cursor 回传续载
		batch, next, err := cli.SScan(ctx, key, uint64(c.Cursor), "*", int64(limit)).Result()
		if err != nil {
			base.Error = errMsg(err)
			base.TimeMs = time.Since(start).Milliseconds()
			return base
		}
		base.Columns = []string{"member"}
		rows := make([]map[string]interface{}, 0, len(batch))
		for _, m := range batch {
			rows = append(rows, map[string]interface{}{"member": m})
		}
		base.Rows = rows
		base.RowCount = len(rows)
		base.NextCursor = int64(next)
		base.Truncated = next != 0
		base.TimeMs = time.Since(start).Milliseconds()
		return base
	case "zset":
		// 偏移分页（按 score 升序）：cursor = 起始排名
		zoffset := c.Cursor
		if zoffset < 0 {
			zoffset = 0
		}
		vals, err := cli.ZRangeWithScores(ctx, key, zoffset, zoffset+int64(limit)-1).Result()
		if err != nil {
			base.Error = errMsg(err)
			base.TimeMs = time.Since(start).Milliseconds()
			return base
		}
		n, _ := cli.ZCard(ctx, key).Result()
		if zoffset+int64(len(vals)) < n {
			base.NextCursor = zoffset + int64(len(vals))
			base.Truncated = true
		}
		base.Columns = []string{"score", "member"}
		rows := make([]map[string]interface{}, 0, len(vals))
		for _, z := range vals {
			rows = append(rows, map[string]interface{}{"score": z.Score, "member": z.Member})
		}
		base.Rows = rows
		base.RowCount = len(rows)
		base.TimeMs = time.Since(start).Milliseconds()
		return base
	default:
		// stream / recon / module types: meta only
		base.Columns = []string{"info"}
		base.Rows = []map[string]interface{}{{"info": fmt.Sprintf("类型 %s 暂不展开，可用命令查看", typ)}}
		base.RowCount = 1
		base.TimeMs = time.Since(start).Milliseconds()
		return base
	}
}

// DeleteRedisKey DEL one key.
func DeleteRedisKey(parent context.Context, c ConnReq) ExecResult {
	start := time.Now()
	key := redisKeyName(c)
	if key == "" {
		return ExecResult{Error: "缺少 key", TimeMs: time.Since(start).Milliseconds()}
	}
	cli, done, err := redisClientFor(c)
	if err != nil {
		return redisErr(start, err)
	}
	defer done()
	ctx, cancel := reqCtxRedis(parent, 5*time.Second)
	defer cancel()
	n, err := cli.Del(ctx, key).Result()
	if err != nil {
		return redisErr(start, err)
	}
	return redisAffected(start, n)
}

// RedisDelPatternResult 按模式批量删除（目录删除）结果。
type RedisDelPatternResult struct {
	Deleted   int    `json:"deleted"`
	Scanned   int    `json:"scanned"`
	Truncated bool   `json:"truncated"`
	Error     string `json:"error"`
	TimeMs    int64  `json:"timeMs"`
}

// 目录删除安全上限：超出即拒绝，防止误配 pattern 造成删库风暴。
const redisDelPatternCap = 10000

// DeleteRedisPattern 按模式批量删除键（SCAN + UNLINK 分批）。用于「删除目录」：
// 前端传 `目录前缀:*`。拒绝全库 `*`；扫描量超上限拒绝。
func DeleteRedisPattern(parent context.Context, c ConnReq) RedisDelPatternResult {
	start := time.Now()
	fail := func(msg string) RedisDelPatternResult {
		return RedisDelPatternResult{Error: msg, TimeMs: time.Since(start).Milliseconds()}
	}
	pat := redisScanPattern(c)
	if pat == "*" || pat == "" {
		return fail("拒绝全库模式删除（*），请指定目录前缀")
	}
	cli, done, err := redisClientFor(c)
	if err != nil {
		return fail(errMsg(err))
	}
	defer done()
	ctx, cancel := reqCtxRedis(parent, 60*time.Second)
	defer cancel()

	names, truncated, err := scanAll(ctx, cli, pat, 500, redisDelPatternCap+1)
	if err != nil {
		return fail(errMsg(err))
	}
	if len(names) > redisDelPatternCap {
		return fail(fmt.Sprintf("匹配键 %d 个超过上限 %d，请缩小目录范围", len(names), redisDelPatternCap))
	}
	total := 0
	for i := 0; i < len(names); i += 500 {
		end := i + 500
		if end > len(names) {
			end = len(names)
		}
		n, err := cli.Unlink(ctx, names[i:end]...).Result()
		if err != nil {
			return RedisDelPatternResult{
				Deleted: total, Scanned: len(names), Truncated: truncated,
				Error: errMsg(err), TimeMs: time.Since(start).Milliseconds(),
			}
		}
		total += int(n)
	}
	return RedisDelPatternResult{
		Deleted: total, Scanned: len(names), Truncated: truncated,
		TimeMs: time.Since(start).Milliseconds(),
	}
}