package main

import (
	"context"
	"fmt"
	"github.com/go-redis/redis/v9"
)

func main() {
	// add
	//add()

	//get()
	//getByLex()

	// pop
	//pop()

	//remove
	//remove()

	// count
	//count()

	// 交集差集并集
	setOp()
}

func setOp() {
	opt, err := redis.ParseURL("redis://default:yourPassword@192.168.157.135:6379/0?dial_timeout=1")
	if err != nil {
		panic(err)
	}

	client := redis.NewClient(opt)
	ctx := context.Background()

	// 初始数据
	client.Del(ctx, "A")
	client.ZAdd(ctx, "A",
		redis.Z{Score: 1, Member: "one"},
		redis.Z{Score: 2, Member: "two"},
		redis.Z{Score: 3, Member: "three"},
	)
	client.Del(ctx, "B")
	client.ZAdd(ctx, "B",
		redis.Z{Score: 22, Member: "two"},
		redis.Z{Score: 33, Member: "three"},
		redis.Z{Score: 44, Member: "four"},
	)

	// 交集
	fmt.Println(client.ZInterWithScores(ctx, &redis.ZStore{
		// 哪些key参与
		Keys: []string{"A", "B"},
		// 权重，聚合时，为每个集合成员增加的权重
		Weights: []float64{2, 3},
		// 聚合方法，默认为 SUM
		Aggregate: "SUM", // 和
		//Aggregate: "MIN", // 使用小的
		//Aggregate: "MAX", // 使用大的
	}).Result())

	// 并集
	fmt.Println(client.ZUnionWithScores(ctx, redis.ZStore{
		// 哪些key参与
		Keys: []string{"A", "B"},
		// 权重，聚合时，为每个集合成员增加的权重
		Weights: []float64{2, 3},
		// 聚合方法，默认为 SUM
		Aggregate: "SUM", // 和
		//Aggregate: "MIN", // 使用小的
		//Aggregate: "MAX", // 使用大的
	}).Result())

	// 差集
	// 不需要聚合运算，保留本集合内的成员集合
	fmt.Println(client.ZDiffWithScores(ctx, "A", "B").Result())
	fmt.Println(client.ZDiffWithScores(ctx, "B", "A").Result())
}

func count() {
	opt, err := redis.ParseURL("redis://default:yourPassword@192.168.157.135:6379/0?dial_timeout=1")
	if err != nil {
		panic(err)
	}

	client := redis.NewClient(opt)
	ctx := context.Background()

	// 初始数据
	client.Del(ctx, "contentViews")
	client.ZAdd(ctx, "contentViews",
		redis.Z{Score: 4, Member: "jia"},
		redis.Z{Score: 2, Member: "yi"},
		redis.Z{Score: 5, Member: "bing"},
		redis.Z{Score: 1, Member: "ding"},
		redis.Z{Score: 0, Member: "wu"},
		redis.Z{Score: 7, Member: "ji"},
		redis.Z{Score: 2, Member: "geng"},
		redis.Z{Score: 1, Member: "xin"},
		redis.Z{Score: 8, Member: "ren"},
		redis.Z{Score: 6, Member: "gui"},
	)

	fmt.Println(client.ZCard(ctx, "contentViews").Result())
	fmt.Println(client.ZCount(ctx, "contentViews", "0", "5").Result())
	//fmt.Println(client.ZCount(ctx, "contentViews", "0", "5").Result())

	// 获取某个成员的排名
	fmt.Println(client.ZRank(ctx, "contentViews", "xin"))
}

func remove() {
	opt, err := redis.ParseURL("redis://default:yourPassword@192.168.157.135:6379/0?dial_timeout=1")
	if err != nil {
		panic(err)
	}

	client := redis.NewClient(opt)
	ctx := context.Background()

	// 初始数据
	client.Del(ctx, "contentViews")
	client.ZAdd(ctx, "contentViews",
		redis.Z{Score: 0, Member: "jia"},
		redis.Z{Score: 0, Member: "yi"},
		redis.Z{Score: 0, Member: "bing"},
		redis.Z{Score: 0, Member: "ding"},
		redis.Z{Score: 0, Member: "wu"},
		redis.Z{Score: 0, Member: "ji"},
		redis.Z{Score: 0, Member: "geng"},
		redis.Z{Score: 0, Member: "xin"},
		redis.Z{Score: 0, Member: "ren"},
		redis.Z{Score: 0, Member: "gui"},
	)
	fmt.Println(client.ZRangeWithScores(ctx, "contentViews", 0, -1).Result())

	// 基于确定成员删除
	//client.ZRem(ctx, "contentViews", "ji", "bing", "geng")
	//fmt.Println(client.ZRangeWithScores(ctx, "contentViews", 0, -1).Result())

	// 基于分值删除范围
	//client.ZRemRangeByScore(ctx, "contentViews", "0", "5")
	//client.ZRemRangeByRank(ctx, "contentViews", 3, 6)
	// 注意全部成员分值要是0
	//client.ZRemRangeByLex(ctx, "contentViews", "[a", "[h")
	//fmt.Println(client.ZRangeWithScores(ctx, "contentViews", 0, -1).Result())
}

func pop() {
	opt, err := redis.ParseURL("redis://default:yourPassword@192.168.157.135:6379/0?dial_timeout=1")
	if err != nil {
		panic(err)
	}

	client := redis.NewClient(opt)
	ctx := context.Background()

	// 初始数据
	client.Del(ctx, "contentViews")
	client.ZAdd(ctx, "contentViews",
		redis.Z{Score: 4, Member: "jia"},
		redis.Z{Score: 2, Member: "yi"},
		redis.Z{Score: 5, Member: "bing"},
		redis.Z{Score: 1, Member: "ding"},
		redis.Z{Score: 0, Member: "wu"},
		redis.Z{Score: 7, Member: "ji"},
		redis.Z{Score: 2, Member: "geng"},
		redis.Z{Score: 1, Member: "xin"},
		redis.Z{Score: 8, Member: "ren"},
		redis.Z{Score: 6, Member: "gui"},
	)
	// 基于score
	fmt.Println(client.ZPopMin(ctx, "contentViews", 4).Result())
	fmt.Println(client.ZRange(ctx, "contentViews", 0, -1).Result())
}

func getByLex() {
	opt, err := redis.ParseURL("redis://default:yourPassword@192.168.157.135:6379/0?dial_timeout=1")
	if err != nil {
		panic(err)
	}

	client := redis.NewClient(opt)
	ctx := context.Background()

	// 初始数据
	client.Del(ctx, "contentViews")
	client.ZAdd(ctx, "contentViews",
		redis.Z{Score: 0, Member: "jia"},
		redis.Z{Score: 0, Member: "yi"},
		redis.Z{Score: 0, Member: "bing"},
		redis.Z{Score: 0, Member: "ding"},
		redis.Z{Score: 0, Member: "wu"},
		redis.Z{Score: 0, Member: "ji"},
		redis.Z{Score: 0, Member: "geng"},
		redis.Z{Score: 0, Member: "xin"},
		redis.Z{Score: 0, Member: "ren"},
		redis.Z{Score: 0, Member: "gui"},
	)

	fmt.Println(client.ZRangeArgs(ctx, redis.ZRangeArgs{
		Key: "contentViews",
		// [a, h]
		//Start: "[a",
		//Stop:  "[h",
		//
		Start: "-",
		Stop:  "+",
		// 基于成员（名字）获取
		ByLex: true,
	}).Result())
}

func get() {
	opt, err := redis.ParseURL("redis://default:yourPassword@192.168.157.135:6379/0?dial_timeout=1")
	if err != nil {
		panic(err)
	}

	client := redis.NewClient(opt)
	ctx := context.Background()

	// 初始数据
	client.Del(ctx, "contentViews")
	client.ZAdd(ctx, "contentViews",
		redis.Z{Score: 4, Member: "jia"},
		redis.Z{Score: 2, Member: "yi"},
		redis.Z{Score: 5, Member: "bing"},
		redis.Z{Score: 1, Member: "ding"},
		redis.Z{Score: 0, Member: "wu"},
		redis.Z{Score: 7, Member: "ji"},
		redis.Z{Score: 2, Member: "geng"},
		redis.Z{Score: 1, Member: "xin"},
		redis.Z{Score: 8, Member: "ren"},
		redis.Z{Score: 6, Member: "gui"},
	)

	// Range获取范围
	//fmt.Println(client.ZRange(ctx, "contentViews", 0, -1).Result())
	//fmt.Println(client.ZRangeWithScores(ctx, "contentViews", 0, -1).Result())
	//fmt.Println(client.ZRangeArgsWithScores(ctx, redis.ZRangeArgs{
	//	Key:   "contentViews",
	//	Start: nil,
	//	Stop:  nil,
	//	// 基于分值获取
	//	ByScore: false,
	//	// 基于成员（名字）获取
	//	ByLex: false,
	//	Rev:   false,
	//	// 偏移
	//	Offset: 0,
	//	// 总计，0表示全部
	//	Count: 0,
	//}))
	fmt.Println(client.ZRangeArgsWithScores(ctx, redis.ZRangeArgs{
		Key: "contentViews",
		// [3, 7]
		//Start: 3,
		//Stop:  7,
		// [3, 7)
		//Start: 3,
		//Stop:  "(7",
		// -inf, 7)
		Start: "-inf",
		Stop:  "(7",
		// 基于分值获取
		ByScore: true,
		// 偏移
		Offset: 3,
		// 总计，0表示全部
		Count: 3,
	}).Result())
	//fmt.Println(client.ZRangeArgs())

	//// 随机获取
	//fmt.Println(client.ZRandMemberWithScores(ctx, "contentViews", 3).Result())
	//fmt.Println(client.ZRandMemberWithScores(ctx, "contentViews", 3).Result())
	//fmt.Println(client.ZRandMemberWithScores(ctx, "contentViews", 3).Result())
	//
	//// 获取某个成员的分值
	//fmt.Println(client.ZMScore(ctx, "contentViews", "gui", "jia", "ji").Result())

}

func add() {
	opt, err := redis.ParseURL("redis://default:yourPassword@192.168.157.135:6379/0?dial_timeout=1")
	if err != nil {
		panic(err)
	}

	client := redis.NewClient(opt)
	ctx := context.Background()

	client.Del(ctx, "contentViews")

	// 快速添加
	//client.ZAdd(ctx, "contentViews", redis.Z{
	//	Score:  4,
	//	Member: "jia",
	//}, redis.Z{
	//	Score:  3,
	//	Member: "yi",
	//}, redis.Z{
	//	Score:  2,
	//	Member: "bing",
	//}, redis.Z{
	//	Score:  10,
	//	Member: "ding",
	//})

	// 完整参数版的 ZAdd，相当于 ZADD 命令
	client.ZAddArgs(ctx, "contentViews", redis.ZAddArgs{
		// 仅仅添加成员，不会去更新当前成员
		NX: false,
		// 仅仅更新存在的成员，不会去添加成员
		XX: false,
		// 只有当成员的新Score小于原有Score时，才去更新。（成员是已经存在的）
		LT: false,
		// 只有当成员的新Score大于原有Score时，才去更新。（成员是已经存在的）
		GT: false,
		// 返回修改的成员数量，包含（添加的和更新的）。默认仅返回添加的
		Ch: false,
		// []Z
		Members: []redis.Z{
			{
				Score:  4,
				Member: "jia",
			}, {
				Score:  3,
				Member: "yi",
			}, {
				Score:  2,
				Member: "bing",
			}, {
				Score:  10,
				Member: "ding",
			}},
	})
	// 查看
	fmt.Println(client.ZRangeWithScores(ctx, "contentViews", 0, -1).Result())

	//result := client.ZAddArgs(ctx, "contentViews", redis.ZAddArgs{
	//	// 仅仅添加成员，不会去更新当前成员
	//	//NX: true,
	//	// 仅仅更新存在的成员，不会去添加成员
	//	//XX: true,
	//	// 只有当成员的新Score小于原有Score时，才去更新。（成员是已经存在的）
	//	//LT: true,
	//	// 只有当成员的新Score大于原有Score时，才去更新。（成员是已经存在的）
	//	//GT: true,
	//	// 返回修改的成员数量，包含（添加的和更新的）。默认仅返回添加的
	//	Ch: true,
	//	// []Z
	//	Members: []redis.Z{
	//		{
	//			Score:  44,
	//			Member: "jia",
	//		}, {
	//			Score:  20,
	//			Member: "wu",
	//		}},
	//})
	//fmt.Println(result.Result())

	// 递增更新
	//client.ZIncrBy(ctx, "contentViews", 20, "bing")
	client.ZIncrBy(ctx, "contentViews", -20, "bing")
	client.ZAddArgsIncr(ctx, "contentViews", redis.ZAddArgs{
		NX:      false,
		XX:      false,
		LT:      false,
		GT:      false,
		Ch:      false,
		Members: nil,
	})

	// 查看
	fmt.Println(client.ZRangeWithScores(ctx, "contentViews", 0, -1).Result())
}