package slot_random

import (
	"gls/lib/gls-server-core/core/flog"
	"math/rand"
	"sync"
	"time"
)

type RandomOps struct {
	Def       *RandItem
	RandomMap map[string]*RandItem
}

func (s *RandomOps) Init(keys []string) {
	var i int64 = 1
	s.Def, i = randValue(i)

	s.RandomMap = map[string]*RandItem{}
	for j := 0; j < len(keys); j++ {
		s.RandomMap[keys[j]], i = randValue(i)
	}
}

var ranDetMap map[string]*RandomOps
var initDetRandomMu sync.Mutex
var isInitDetRandom = false

var randkeys []string

func InitRandom(keys []string) {
	if isInitDetRandom {
		return
	}
	initDetRandomMu.Lock()
	defer initDetRandomMu.Unlock()
	isInitDetRandom = true
	if ranDetMap == nil {
		ranDetMap = map[string]*RandomOps{}
	}

	ops := "平台"
	ranDetMap[ops] = &RandomOps{}
	ranDetMap[ops].Init(keys)
}

func (s *RandomOps) Intn(n int, key string) int {
	v, ok := s.RandomMap[key]
	if ok {
		return v.Intn(n)
	}
	return s.Def.Intn(n)
}

func (s *RandomOps) Float64(key string) float64 {
	v, ok := s.RandomMap[key]
	if ok {
		return v.Float64()
	}
	return s.Def.Float64()
}

func randValue(i int64) (*RandItem, int64) {
	randGen := rand.New(rand.NewSource(time.Now().UnixNano() / i))
	random := rand.New(rand.NewSource(int64(randGen.Uint64())))
	i++
	ret := &RandItem{
		Random: random,
	}
	return ret, i
}

func GetRandomOps(ops string) *RandomOps {
	InitRandom(randkeys)
	if ops == "" {
		ops = "平台"
	}
	_, ok := ranDetMap[ops]
	if ok {
		v1, ok1 := ranDetMap[ops]
		if ok1 {
			return v1
		}
	}
	flog.Log.Warnf("GetRandomOps ", ops, " failed")
	go InitOpsRandomOne(ops, randkeys)
	return nil
}

var initDetRandomOneMu sync.Mutex

func InitOpsRandomOne(ops string, keys []string) {
	initDetRandomOneMu.Lock()
	defer initDetRandomOneMu.Unlock()
	_, ok := ranDetMap[ops]
	if !ok {
		ranDetMap[ops] = &RandomOps{}
		ranDetMap[ops].Init(keys)
	}
}