package bench

import (
	"context"
	"fmt"
	"go_dreamfactory/sys/cache"
	"os"
	"testing"

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

var LusScriptgetList = `
local key    = tostring(KEYS[1])
local keyss = redis.call("HGETALL", key)
local data = {}
local n = 1
for i, v in ipairs(keyss) do
	if i%2 == 0 then
		data[n] = redis.call("HGETALL", v)
		n = n+1
	end
end 
return data
`
var res string

func TestMain(m *testing.M) {
	if err := cache.OnInit(nil, cache.Set_Redis_Addr([]string{
		// "10.0.0.9:6986",
		"10.0.0.9:9001", "10.0.0.9:9002", "10.0.0.9:9003", "10.0.0.9:9004", "10.0.0.9:9005", "10.0.0.9:9006",
	}),
		cache.Set_Redis_Password(""),
		// cache.Set_Redis_Password("li13451234"),
		// cache.Set_Redis_DB(0),
		cache.Set_Redis_IsCluster(true)); err != nil {
		fmt.Printf("err:%v\n", err)
		return
	}
	var err error

	res, err = cache.Redis().NewScript(LusScriptgetList).Result()
	if err != nil {
		fmt.Println("err:", err)
	}
	defer os.Exit(m.Run())
}

func BenchmarkRedis(b *testing.B) {
	uid := "2_62ec8ab8828fb7bf67b220b6"
	heroRedisKey := fmt.Sprintf("hero_%s%s", uid, "{herotest}")
	var (
		// ncpu = runtime.NumCPU()
		parallelisms = []int{4, 16, 64}
		dataSizes    = []int{100, 1000, 10000}
		numKeys      = 1024
		key          = heroRedisKey
		// keys         = []string{
		// 	"hero:0_62d6131a3a719b898a90b5fb-62d6131a3a719b898a90b5fe",
		// 	"hero:0_62d6131a3a719b898a90b5fb-62d6131a3a719b898a90b600",
		// 	"hero:0_62d6131a3a719b898a90b5fb-62d661d6bca6eab554879fc6",
		// 	"hero:0_62d6131a3a719b898a90b5fb-62d6694dbca6eab554879fef",
		// 	// "hero:0_62bbf14cf88fbd265e61a121-62bbf1849d64e5ee7ff12529",
		// 	// "hero:0_62bbf364f88fbd265e61a122-62bbf5189b1970ed6b28b638",
		// 	// "hero:0_62bbf364f88fbd265e61a122-62bbf5189b1970ed6b28b63e",
		// 	// "hero:0_62bbf57346a32c12466c2e64-62bbf58d9b1970ed6b28b643",
		// }
		builders = []TargetBuilder{
			{
				Name: "pipeline",
				Make: func(bench Benchmark) (Target, error) {

					return Target{
						Get: func() {
							ctx := context.Background()
							keys, _ := cache.Redis().HGetAllToMapString(key)
							// fmt.Println(keys)
							for _, v := range keys {
								cache.Redis().Pipelined(ctx, func(pipe redis.Pipeliner) error {
									pipe.HGetAll(ctx, v).Result()
									_, err := pipe.Exec(ctx)
									// fmt.Println(v)
									return err
								})
							}
						},
					}, nil
				},
			},
			{
				Name: "lua",
				Make: func(bench Benchmark) (Target, error) {
					return Target{
						Get: func() {

							if _, err := cache.Redis().EvalSha(context.Background(), res, []string{key}).Result(); err != nil {
								fmt.Println(err)
							} else {
								// fmt.Println(v)
							}

						},
					}, nil
				},
			},
		}
	)

	RunBenchmark(b, compose(parallelisms, dataSizes, numKeys, builders))
}