package uid

import (
	"context"
	"fmt"
	"github.com/bwmarrin/snowflake"
	"hash/fnv"
	"math"
	"os"
	"sync"
	"testing"

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

func TestSignGenerator_GetNumber(t *testing.T) {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "47.97.27.195:6379",
		Password: "lansexiongdi@666",
		DB:       15,
	})

	number, err := NewSignGenerator(rdb).SetWorkerID(1).SetServerID(2).GetNumber()
	if err != nil {
		t.Error(err)
		return
	}

	t.Log(number)
}

func TestSignGenerator_Num(t *testing.T) {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "47.97.27.195:6379",
		Password: "lansexiongdi@666",
		DB:       15,
	})

	var ids sync.Map
	var wg sync.WaitGroup
	const concurrency = 2000
	wg.Add(concurrency)
	for i := 0; i < concurrency; i++ {
		go func() {
			defer wg.Done()
			id, err := NewSignGenerator(rdb).SetWorkerID(1).SetServerID(2).GetNumber()
			if err != nil {
				t.Error(err)
				return
			}
			if _, exists := ids.LoadOrStore(id, true); exists {
				t.Errorf("duplicate ID generated")
			}
		}()
	}
	wg.Wait()
}

func TestSignGenerator_ReverseNumber(t *testing.T) {
	reverseNumber := NewSignGenerator(nil).ReverseNumber(556081583078248449)
	t.Log(reverseNumber)
}

func Test_GenerateNo(t *testing.T) {
	//no := GenerateNo()
	//
	//t.Log(len(no))
	//t.Log(no)

	p := os.Getpid()

	t.Log(p)
	t.Log(p % 1000)

	//uid := uuid.New().String()
	//t.Log(len(uid))
	//t.Log(uid)

	ctx := context.Background()
	serverIdStr := GetAppId(ctx)

	t.Log(serverIdStr)
	t.Log(hashMod(serverIdStr))

	node, err := snowflake.NewNode(1023)
	if err != nil {
		t.Error(err)
		return
	}

	nid := node.Generate().String()

	t.Log(len(nid))
	t.Log(nid)
}

func hashMod(hashStr string) int {
	hash := fnv.New32a()
	_, _ = hash.Write([]byte(hashStr))

	hashValue := hash.Sum32()
	return int(math.Mod(float64(hashValue), 32))
}

func GenerateSnowflakeID(nodeID int64) (string, error) {
	if nodeID < 0 || nodeID > 1023 {
		return "", fmt.Errorf("invalid node ID: %d", nodeID)
	}
	node, err := snowflake.NewNode(nodeID)
	if err != nil {
		return "", err
	}
	return node.Generate().String(), nil
}

func TestGenerateID(t *testing.T) {
	nodeID := int64(1) // 确保唯一
	node, _ := snowflake.NewNode(nodeID)
	var ids sync.Map
	var wg sync.WaitGroup
	const concurrency = 2000
	wg.Add(concurrency)
	for i := 0; i < concurrency; i++ {
		go func() {
			defer wg.Done()
			id := node.Generate().String()
			if _, exists := ids.LoadOrStore(id, true); exists {
				t.Errorf("duplicate ID generated")
			}
		}()
	}
	wg.Wait()
}