package redis

import (
	"context"
	"f1-game/internal/enum"
	nameRedis "f1-game/internal/name/redis"
	"f1-game/internal/pb"
	"fmt"
	"strings"
	"testing"
	"time"

	clog "github.com/cherry-game/cherry/logger"
	cprofile "github.com/cherry-game/cherry/profile"
	"github.com/go-redis/redis/v8"
	jsoniter "github.com/json-iterator/go"
)

func TestMain(m *testing.M) {
	path := "../../../etc/profile/dev.json"
	_, err := cprofile.Init(path, "1")
	if err != nil {
		return
	}

	Game = newGame()
	Game.setKey()
	Game.client = newClient("test", &redis.Options{
		Addr:     "192.168.1.232:46379",
		Password: "H+5QfwG0jE3C@Plvgikb",
		DB:       0,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected!", "test")
			return nil
		},
	})

	m.Run()
}

func TestNew111(t *testing.T) {
	msg := &pb.ChatMsg{
		MsgID: 1000,
		Sender: &pb.ChatPlayer{
			GameNodeID: "1",
			PlayerID:   100000001,
			PlayerName: "qwqa",
		},
		SendTime: 0,
		Type:     0,
		Text:     "",
	}

	str, _ := jsoniter.MarshalToString(msg)
	fmt.Println(str)
}

func TestLua1(t *testing.T) {
	lua := `local uid = redis.call("GET", KEYS[1])

if not uid or tonumber(uid) < 1 then
    redis.call("SET", KEYS[1], ARGV[1])
    return ARGV[1]
else
    return uid
end`

	script := redis.NewScript(lua)
	rdb := newTestRedis("dev.com:6379", "z~DquqVqQbGwD78^", 1)

	cmd := script.Run(context.Background(), rdb, []string{"uid_1"}, 2)
	fmt.Println(cmd.Int())
}

func TestLua2(t *testing.T) {
	lua := `
redis.call('RPUSH', KEYS[1], ARGV[1])

local currentSize = redis.call('LLEN', KEYS[1])
local maxSize = tonumber(ARGV[2])
while currentSize > maxSize do
    redis.call('LPOP', KEYS[1])
    currentSize = currentSize - 1
end

return currentSize
`

	script := redis.NewScript(lua)
	rdb := newTestRedis("dev.com:6379", "z~DquqVqQbGwD78^", 1)

	cmd := script.Run(context.Background(), rdb, []string{"queue"}, 333, 20)
	fmt.Println(cmd.Int())
}

func TestGetRedis(t *testing.T) {
	address := "dev.com:6379"
	pwd := "123456"

	rdb := newTestRedis(address, pwd, 5)
	key := "key"
	value := "hello world"
	rdb.Set(context.Background(), key, value, 10*time.Minute)
}

func BenchmarkRedisSet(b *testing.B) {
	address := "dev.com:6379"
	pwd := "123456"
	rdb := newTestRedis(address, pwd, 5)

	key := "key"
	value := "hello world"
	expiration := 10 * time.Minute

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		rdb.Set(context.Background(), key, value, expiration)
	}
}

func BenchmarkRedisGet(b *testing.B) {
	address := "dev.com:6379"
	pwd := "123456"
	rdb := newTestRedis(address, pwd, 5)

	key := "key"

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		rdb.Get(context.Background(), key)
	}
}

func BenchmarkRedisIncr(b *testing.B) {
	address := "dev.com:6379"
	pwd := "123456"
	rdb := newTestRedis(address, pwd, 5)

	key := "incr"

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		rdb.Incr(context.Background(), key)
	}
}

func newTestRedis(address, pwd string, db int) *redis.Client {
	rdb := redis.NewClient(&redis.Options{
		Addr:     address,
		Password: pwd,
		DB:       db,
		PoolSize: 32,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Info("connected!")
			return nil
		},
	})

	return rdb
}

func TestSyncUIDKey(t *testing.T) {
	db := 4 // 2
	rdb := newTestRedis("dev.com:6379", "z~DquqVqQbGwD78^", db)

	newKeyPattern := "center:uids:%s" // pid
	keyPattern := "center:uid:*"

	keyList, err := rdb.Keys(context.Background(), keyPattern).Result()
	if err != nil {
		return
	}

	uidMaps := map[string]map[string]string{}

	for _, k := range keyList {
		splits := strings.Split(k, ":")
		if len(splits) != 3 {
			fmt.Println("splits error")
			continue
		}

		kv := strings.Split(splits[2], "_")
		if len(kv) != 2 {
			fmt.Println("kv error")
			continue
		}

		uid, err := rdb.Get(context.Background(), k).Result()
		if err != nil {
			fmt.Println(err)
			continue
		}

		pid := kv[0]
		openID := kv[1]

		openMaps, found := uidMaps[pid]
		if !found {
			openMaps = map[string]string{}
			uidMaps[pid] = openMaps
		}
		openMaps[openID] = uid
	}

	fmt.Println(len(uidMaps))

	for pid, openMap := range uidMaps {
		fmt.Printf("pid = %s, len= %d\n", pid, len(openMap))

		key := fmt.Sprintf(newKeyPattern, pid)
		for openID, uid := range openMap {
			rdb.HSetNX(context.Background(), key, openID, uid)
		}
	}
}

func TestSyncLastLoginKey(t *testing.T) {
	db := 4 // 2
	rdb := newTestRedis("dev.com:6379", "z~DquqVqQbGwD78^", db)

	newKeyPattern := "center:last-login:%s" // pid
	keyPattern := "center:last_login:*"

	keyList, err := rdb.Keys(context.Background(), keyPattern).Result()
	if err != nil {
		return
	}

	fmt.Println(len(keyList))

	loginMaps := map[string]map[string]string{}

	for _, k := range keyList {
		splits := strings.Split(k, ":")
		if len(splits) != 3 {
			fmt.Println("splits error")
			continue
		}

		kv := strings.Split(splits[2], "_")
		if len(kv) != 2 {
			fmt.Println("kv error")
			continue
		}

		json, err := rdb.Get(context.Background(), k).Result()
		if err != nil {
			fmt.Println(err)
			continue
		}

		pid := kv[0]
		openID := kv[1]

		openMaps, found := loginMaps[pid]
		if !found {
			openMaps = map[string]string{}
			loginMaps[pid] = openMaps
		}
		openMaps[openID] = json
	}

	fmt.Println(len(loginMaps))

	for pid, openMap := range loginMaps {
		fmt.Printf("pid = %s, len= %d\n", pid, len(openMap))

		key := fmt.Sprintf(newKeyPattern, pid)
		for openID, json := range openMap {
			rdb.HSetNX(context.Background(), key, openID, json)
		}
	}
}

func TestSyncServerListKey(t *testing.T) {
	db := 4 // 2
	rdb := newTestRedis("dev.com:6379", "z~DquqVqQbGwD78^", db)

	newKeyPattern := "center:server-list:%s" // pid
	keyPattern := "center:server_list:*"

	keyList, err := rdb.Keys(context.Background(), keyPattern).Result()
	if err != nil {
		return
	}

	serverListMaps := map[string]string{}

	for _, k := range keyList {
		splits := strings.Split(k, ":")
		if len(splits) != 3 {
			fmt.Println("splits error")
			continue
		}

		json, err := rdb.Get(context.Background(), k).Result()
		if err != nil {
			fmt.Println(err)
			continue
		}

		pid := splits[2]
		serverListMaps[pid] = json
	}

	fmt.Println(len(serverListMaps))

	for pid, json := range serverListMaps {
		key := fmt.Sprintf(newKeyPattern, pid)
		rdb.Set(context.Background(), key, json, NoExpire)
	}
}

func TestSyncPlayer(t *testing.T) {
	db := 1
	rdb := newTestRedis("dev.com:6379", "z~DquqVqQbGwD78^", db)

	newKeyPattern := "cross-1:player"
	keyPattern := "cross-1-player-detail:*"

	keyList, err := rdb.Keys(context.Background(), keyPattern).Result()
	if err != nil {
		return
	}

	fmt.Println(len(keyList))

	for _, key := range keyList {

		sc := rdb.Get(context.Background(), key)
		if sc.Err() != nil {
			t.Error("read fail: ", key, sc.Err().Error())
			continue
		}

		ss := strings.Split(key, ":")
		if len(ss) < 2 {
			t.Error("error key: ", key)
			continue
		}

		ic := rdb.HSet(context.Background(), newKeyPattern, ss[1], sc.Val())
		if ic.Err() != nil {
			t.Error("write fail: ", newKeyPattern, ss[1], ic.Err().Error())
		}

	}
}

func TestAddChatMsg(t *testing.T) {
	address := "192.168.1.232:46379"
	pwd := "H+5QfwG0jE3C@Plvgikb"
	redisID := "test"
	options := &redis.Options{
		Addr:     address,
		Password: pwd,
		DB:       4,
		PoolSize: 64,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected! [address = %s]", redisID, address)
			return nil
		},
	}
	cli := newClient(redisID, options)
	c := newChat()
	c.load(cli)
	var (
		start = 30000
		count = start + 300
	)
	for i := start; i < count; i++ {
		pb := &pb.ChatMsg{
			MsgID: int64(i),
			Sender: &pb.ChatPlayer{
				PlayerID:   int64(100000 + i),
				PlayerName: fmt.Sprintf("玩家_%d", i),
			},
			Type: 1,
			Text: fmt.Sprintf("这是测试%d", i),
		}
		c.AddMsg(enum.ChatType_Game, 1, 200, pb)
	}

	list := c.GetChatMsgs(enum.ChatType_Game, 1, 0)
	for _, message := range list.List {
		fmt.Println(message)
	}

}
func TestDelChatMsg(t *testing.T) {
	address := "192.168.1.232:46379"
	pwd := "H+5QfwG0jE3C@Plvgikb"
	redisID := "test_chat_redis_id"
	options := &redis.Options{
		Addr:     address,
		Password: pwd,
		DB:       4,
		PoolSize: 64,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected! [address = %s]", redisID, address)
			return nil
		},
	}
	cli := newClient(redisID, options)
	c := newChat()
	c.load(cli)
	c.DelMsgByMsgID(enum.ChatType_Game, 1, 10003)

	list := c.GetChatMsgs(enum.ChatType_Game, 1, 0)
	for _, message := range list.List {
		fmt.Println(message)
	}
}

func TestGetChatMsg(t *testing.T) {
	address := "192.168.1.232:46379"
	pwd := "H+5QfwG0jE3C@Plvgikb"
	redisID := "test_chat_redis_id"
	options := &redis.Options{
		Addr:     address,
		Password: pwd,
		DB:       4,
		PoolSize: 64,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected! [address = %s]", redisID, address)
			return nil
		},
	}
	cli := newClient(redisID, options)
	c := newChat()
	c.load(cli)
	list := c.GetChatMsgs(enum.ChatType_Game, 1, 0)
	for _, message := range list.List {
		fmt.Println(message)
	}
}

func TestPlayerData(t *testing.T) {
	game := newGame()
	game.client = newClient("test", &redis.Options{
		Addr:     "192.168.1.232:46379",
		Password: "H+5QfwG0jE3C@Plvgikb",
		DB:       0,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected!", "test")
			return nil
		},
	})

	// result := game.SavePlayerDataFields(10001, map[string]any{
	// 	nameRedis.Player_PlayerID:   10001,
	// 	nameRedis.Player_PlayerName: "玩家10001",
	// 	nameRedis.Player_LordLevel:  50,
	// 	nameRedis.Player_IconID:     1,
	// 	nameRedis.Player_FrameID:    1,
	// 	nameRedis.Player_LeagueID:   1,
	// 	nameRedis.Player_LeagueName: "联盟1",
	// 	nameRedis.Player_GameNodeID: 1,
	// 	nameRedis.Player_MapNodeID:  1,
	// })

	// fmt.Println(result)
	// result = game.SavePlayerDataFields(10002, map[string]any{
	// 	nameRedis.Player_PlayerID:   10002,
	// 	nameRedis.Player_PlayerName: "玩家10002",
	// 	nameRedis.Player_LordLevel:  100,
	// 	nameRedis.Player_IconID:     2,
	// 	nameRedis.Player_FrameID:    2,
	// 	nameRedis.Player_LeagueID:   2,
	// 	nameRedis.Player_LeagueName: "联盟2",
	// 	nameRedis.Player_GameNodeID: 2,
	// 	nameRedis.Player_MapNodeID:  2,
	// })

	// fmt.Println(result)

	// playerData := game.GetPlayerData(10001, nameRedis.PlayerChatFields...)
	// if playerData != nil {
	// 	fmt.Printf("playerData = %+v\n", playerData)
	// }

	// list := game.GetPlayerDataList([]int64{10001, 10002}, nameRedis.PlayerChatFields...)
	// fmt.Printf("list = %+v\n", list)
	// for _, playerData := range list {
	// 	fmt.Printf("playerData = %+v\n", playerData)
	// }

	maps := game.GetPlayerDataMap([]int64{10001, 10002, 111}, nameRedis.PlayerChatFields...)
	fmt.Printf("map = %+v\n", maps)
	// for _, playerData := range maps {
	// 	fmt.Printf("playerData = %+v\n", playerData)
	// }
}

func BenchmarkGetPlayerData(b *testing.B) {
	game := newGame()
	game.client = newClient("test", &redis.Options{
		Addr:     "192.168.1.232:46379",
		Password: "H+5QfwG0jE3C@Plvgikb",
		DB:       0,
	})

	b.ResetTimer()
	for b.Loop() {
		game.GetPlayerData(10001, nameRedis.PlayerChatFields...)
	}
}

func BenchmarkParllelGetPlayerData(b *testing.B) {
	game := newGame()
	game.client = newClient("test", &redis.Options{
		Addr:     "192.168.1.232:46379",
		Password: "H+5QfwG0jE3C@Plvgikb",
		DB:       0,
	})

	b.ResetTimer()
	b.RunParallel(func(p *testing.PB) {
		for p.Next() {
			game.GetPlayerData(10001, nameRedis.PlayerChatFields...)
		}
	})

}

func TestAddGroupMember(t *testing.T) {
	address := "192.168.1.232:46379"
	pwd := "H+5QfwG0jE3C@Plvgikb"
	redisID := "test_chat_redis_id"
	options := &redis.Options{
		Addr:     address,
		Password: pwd,
		DB:       4,
		PoolSize: 64,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected! [address = %s]", redisID, address)
			return nil
		},
	}
	cli := newClient(redisID, options)
	c := newChat()
	c.load(cli)
	var (
		start = 100000
		count = start + 100
	)
	for i := start; i < count; i++ {
		c.AddGroupMember(1, int64(i))
	}

	list, _ := c.GetGroupMembers(1)
	for _, message := range list {
		fmt.Println(message)
	}

	c.DelGroupMember(1, 100000)
	// c.DelAllGroupMembers(1)
}

func TestSavePlayerTeam(t *testing.T) {
	var (
		playerID = int64(1)
		teams    []*pb.BattleTeam
	)

	teams = append(teams, &pb.BattleTeam{
		TeamID: 1,
		Members: map[int64]*pb.BattleTeamMember{
			1: {
				Index:       1,
				HeroGUID:    1,
				TroopsNum:   1,
				TroopsLimit: 1,
			},
		},
	})

	teams = append(teams, &pb.BattleTeam{
		TeamID: 2,
		Members: map[int64]*pb.BattleTeamMember{
			2: {
				Index:       2,
				HeroGUID:    2,
				TroopsNum:   2,
				TroopsLimit: 2,
			},
		},
	})

	Game.UpdatePlayerTeams(playerID, teams...)
}

func TestGetPlayerTeams(t *testing.T) {
	// teams := Game.GetPlayerTeams(1)
	teams := Game.GetPlayerTeamsByID(1, 1)
	for _, team := range teams {
		fmt.Println(team)
	}
}

func TestGetPlayerTeamBattleSquadParam(t *testing.T) {
	path := "../../../etc/profile/dhc.json"
	_, err := cprofile.Init(path, "4")
	if err != nil {
		clog.Errorf("[TestGetPlayerTeamBattleSquadParam] error: %v", err)
		return
	}

	game := newGame()
	client := newClient("test", &redis.Options{
		Addr:     "192.168.1.232:46379",
		Password: "H+5QfwG0jE3C@Plvgikb",
		DB:       0,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected!", "test")
			return nil
		},
	})
	game.load(client)

	battleTeamDataList := []*pb.BattleTeamData{
		{
			PlayerID:  1048717,
			TeamID:    1,
			TeamHeros: []int64{1048723, 1048724, 1048718},
		},
	}
	teams, heros := game.GetPlayerBattleData(battleTeamDataList...)
	for _, team := range teams {
		fmt.Printf("team = %+v\n", team)
	}
	for _, hero := range heros {
		fmt.Printf("hero = %+v\n", hero)
	}
	// teams := game.GetBatchPlayerBattleSquadParams(map[int64]int32{1048577: 1, 1048766: 1})
	// for playerID, team := range teams {
	// 	fmt.Printf("playerID = %d, team = %+v\n", playerID, team)
	// }
}

func TestGetPlayerHeroData(t *testing.T) {
	playerData, teamData, heroData := Game.GetPlayerTeamHeroData(13332255, 1, 13332256)
	fmt.Printf("%+v\n", playerData)
	fmt.Printf("%+v\n", teamData)
	fmt.Printf("%+v\n", heroData)
}

func TestDelGroupKey(t *testing.T) {
	path := "../../../etc/profile/dhc.json"
	_, err := cprofile.Init(path, "4")
	if err != nil {
		clog.Errorf("[TestDelGroupKey] error: %v", err)
		return
	}

	chat := newChat()
	client := newClient("test", &redis.Options{
		Addr:     "192.168.1.232:46379",
		Password: "H+5QfwG0jE3C@Plvgikb",
		DB:       0,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected!", "test")
			return nil
		},
	})
	chat.load(client)
	// chat.DelAllGroupMembers(1041)
	memberIDList := []int64{1048950}
	chat.DelGroupMember(1053, memberIDList...)
}

func TestPrivateMsg(t *testing.T) {
	path := "../../../etc/profile/dhc.json"
	_, err := cprofile.Init(path, "4")
	if err != nil {
		clog.Errorf("[TestDelGroupKey] error: %v", err)
		return
	}

	chat := newChat()
	client := newClient("test", &redis.Options{
		Addr:     "192.168.1.232:46379",
		Password: "H+5QfwG0jE3C@Plvgikb",
		DB:       0,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected!", "test")
			return nil
		},
	})
	chat.load(client)
	msg := chat.GetPrivateMsgs(1049577, 1049519, 673969073461377984)
	for _, message := range msg.List {
		fmt.Println(message)
	}
	// msg := chat.GetChatMsgList(enum.ChatType_Game, 4, 673975895220009920)
	// for _, message := range msg.List {
	// 	fmt.Println(message)
	// }
}

func TestExchangeLog(t *testing.T) {
	path := "../../../etc/profile/dhc.json"
	_, err := cprofile.Init(path, "4")
	if err != nil {
		clog.Errorf("[TestDelGroupKey] error: %v", err)
		return
	}

	game := newGame()
	client := newClient("test", &redis.Options{
		Addr:     "192.168.1.232:46379",
		Password: "H+5QfwG0jE3C@Plvgikb",
		DB:       0,
		OnConnect: func(ctx context.Context, cn *redis.Conn) error {
			clog.Infof("[redisID = %s] connected!", "test")
			return nil
		},
	})
	game.load(client)
	logs := game.GetMapExchangeLogList("map-1", 1049577, enum.ExchangeLogType_Buy, 673986573804095553)
	fmt.Printf("logs len = %d \n", len(logs.List))
	for _, log := range logs.List {
		fmt.Println(log)
	}
}