package common

import (
	crand "crypto/rand"
	mrand "math/rand"
	"sync"
	"time"
)

const (
	strChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" // 62 characters
)

// pseudo random number generator.
// seeded with OS randomness (crand)
var prng struct {
	sync.Mutex
	*mrand.Rand
}

func reset() {
	b := cRandBytes(8)
	var seed uint64
	for i := 0; i < 8; i++ {
		seed |= uint64(b[i])
		seed <<= 8
	}
	prng.Lock()
	prng.Rand = mrand.New(mrand.NewSource(int64(seed)))
	prng.Unlock()
}

func init() {
	reset()
}

// Constructs an alphanumeric string of given length.
// It is not safe for cryptographic usage.
func RandStr(length int) string {
	chars := []byte{}
MAIN_LOOP:
	for {
		val := RandInt63()
		for i := 0; i < 10; i++ {
			v := int(val & 0x3f) // rightmost 6 bits
			if v >= 62 {         // only 62 characters in strChars
				val >>= 6
				continue
			} else {
				chars = append(chars, strChars[v])
				if len(chars) == length {
					break MAIN_LOOP
				}
				val >>= 6
			}
		}
	}

	return string(chars)
}

// It is not safe for cryptographic usage.
func RandUint16() uint16 {
	return uint16(RandUint32() & (1<<16 - 1))
}

// It is not safe for cryptographic usage.
func RandUint32() uint32 {
	prng.Lock()
	u32 := prng.Uint32()
	prng.Unlock()
	return u32
}

// It is not safe for cryptographic usage.
func RandUint64() uint64 {
	return uint64(RandUint32())<<32 + uint64(RandUint32())
}

// It is not safe for cryptographic usage.
func RandUint() uint {
	prng.Lock()
	i := prng.Int()
	prng.Unlock()
	return uint(i)
}

// It is not safe for cryptographic usage.
func RandInt16() int16 {
	return int16(RandUint32() & (1<<16 - 1))
}

// It is not safe for cryptographic usage.
func RandInt32() int32 {
	return int32(RandUint32())
}

// It is not safe for cryptographic usage.
func RandInt64() int64 {
	return int64(RandUint64())
}

// It is not safe for cryptographic usage.
func RandInt() int {
	prng.Lock()
	i := prng.Int()
	prng.Unlock()
	return i
}

// It is not safe for cryptographic usage.
func RandInt31() int32 {
	prng.Lock()
	i31 := prng.Int31()
	prng.Unlock()
	return i31
}

// It is not safe for cryptographic usage.
func RandInt63() int64 {
	prng.Lock()
	i63 := prng.Int63()
	prng.Unlock()
	return i63
}

// Distributed pseudo-exponentially to test for various cases
// It is not safe for cryptographic usage.
func RandUint16Exp() uint16 {
	bits := RandUint32() % 16
	if bits == 0 {
		return 0
	}
	n := uint16(1 << (bits - 1))
	n += uint16(RandInt31()) & ((1 << (bits - 1)) - 1)
	return n
}

// Distributed pseudo-exponentially to test for various cases
// It is not safe for cryptographic usage.
func RandUint32Exp() uint32 {
	bits := RandUint32() % 32
	if bits == 0 {
		return 0
	}
	n := uint32(1 << (bits - 1))
	n += uint32(RandInt31()) & ((1 << (bits - 1)) - 1)
	return n
}

// Distributed pseudo-exponentially to test for various cases
// It is not safe for cryptographic usage.
func RandUint64Exp() uint64 {
	bits := RandUint32() % 64
	if bits == 0 {
		return 0
	}
	n := uint64(1 << (bits - 1))
	n += uint64(RandInt63()) & ((1 << (bits - 1)) - 1)
	return n
}

// It is not safe for cryptographic usage.
func RandFloat32() float32 {
	prng.Lock()
	f32 := prng.Float32()
	prng.Unlock()
	return f32
}

// It is not safe for cryptographic usage.
func RandTime() time.Time {
	return time.Unix(int64(RandUint64Exp()), 0)
}

// RandBytes returns n random bytes from the OS's source of entropy ie. via crypto/rand.
// It is not safe for cryptographic usage.
func RandBytes(n int) []byte {
	// cRandBytes isn't guaranteed to be fast so instead
	// use random bytes generated from the internal PRNG
	bs := make([]byte, n)
	for i := 0; i < len(bs); i++ {
		bs[i] = byte(RandInt() & 0xFF)
	}
	return bs
}

// RandIntn returns, as an int, a non-negative pseudo-random number in [0, n).
// It panics if n <= 0.
// It is not safe for cryptographic usage.
func RandIntn(n int) int {
	prng.Lock()
	i := prng.Intn(n)
	prng.Unlock()
	return i
}

// RandPerm returns a pseudo-random permutation of n integers in [0, n).
// It is not safe for cryptographic usage.
func RandPerm(n int) []int {
	prng.Lock()
	perm := prng.Perm(n)
	prng.Unlock()
	return perm
}

// NOTE: This relies on the os's random number generator.
// For real security, we should salt that with some seed.
// See github.com/tendermint/go-crypto for a more secure reader.
func cRandBytes(numBytes int) []byte {
	b := make([]byte, numBytes)
	_, err := crand.Read(b)
	if err != nil {
		PanicCrisis(err)
	}
	return b
}