package util

import (
	"encoding/binary"
	"math"
	"math/rand"
	"net/url"
	"strconv"
	"strings"
	"time"
	"game/base/log"
)

func init() {
	rand.Seed(time.Now().UnixNano())
}

func StringToUint64(i string) uint64 {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseUint(i, 10, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return d
}

func StringToInt64(i string) int64 {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseInt(i, 10, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return d
}

func StringToUint32(i string) uint32 {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseUint(i, 10, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return uint32(d)
}
func StringToInt32(i string) int32 {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseInt(i, 10, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return int32(d)
}

func StringToInt(i string) int {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseInt(i, 10, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return int(d)
}
func StringToUint16(i string) uint16 {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseUint(i, 10, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return uint16(d)
}
func StringToUint8(i string) uint8 {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseUint(i, 10, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return uint8(d)
}

func StringToFloat64(i string) float64 {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseFloat(i, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return d
}

func StringToFloat32(i string) float32 {
	if i == "" {
		return 0
	}
	d, e := strconv.ParseFloat(i, 64)
	if e != nil {
		log.Info("string convent err ", i, e)
		return 0
	}
	return float32(d)
}

func StringToBool(i string) bool {
	if i == "" {
		return false
	}
	d, e := strconv.ParseBool(i)
	if e != nil {
		log.Error("strconv ParseBool err ", e)
		return false
	}
	return d
}

func StringToSliceUint32(str string) []uint32 {
	var r []uint32
	tmp := strings.Split(str, "-")
	for _, t := range tmp {
		r = append(r, StringToUint32(t))
	}
	return r
}
func StringToSliceUint64(str string) []uint64 {
	var r []uint64
	tmp := strings.Split(str, "-")
	for _, t := range tmp {
		r = append(r, StringToUint64(t))
	}
	return r
}
func StringToSliceInt(str string) []int {
	var r []int
	tmp := strings.Split(str, "-")
	for _, t := range tmp {
		r = append(r, StringToInt(t))
	}
	return r
}
func Uint64ToString(i uint64) string {
	return strconv.FormatUint(i, 10)
}

func Uint32ToString(i uint32) string {
	return strconv.FormatUint(uint64(i), 10)
}

func Int64ToString(i int64) string {
	return strconv.FormatInt(i, 10)
}

func IntToString(i int) string {
	return strconv.FormatInt(int64(i), 10)
}

func Float32ToString(i float32) string {
	return strconv.FormatFloat(float64(i), 'f', 6, 64)
}

func Float64ToString(i float64) string {
	return strconv.FormatFloat(i, 'f', 6, 64)
}

func BoolToString(i bool) string {
	return strconv.FormatBool(i)
}

func Int64ToBytes(i int64) []byte {
	var buf = make([]byte, 8)
	binary.BigEndian.PutUint64(buf, uint64(i))
	return buf
}

func BytesToInt64(buf []byte) int64 {
	return int64(binary.BigEndian.Uint64(buf))
}

//进行四舍五入，保留n位小数
func RoundFloat(f float64, n int) float64 {
	pow10_n := math.Pow10(n)
	return math.Trunc((f+0.5/pow10_n)*pow10_n) / pow10_n
}

//不进行四舍五入，保留n位小数
func NoRoundFloat(f float64, n int) float64 {
	pow10_n := math.Pow10(n)
	return math.Trunc(f*pow10_n) / pow10_n
}

//[]uint32转化为[]byte
func Uint32sToBytes(args []uint32) []byte {
	bytes := make([]byte, 0)
	for _, arg := range args {
		b := make([]byte, 4)
		binary.BigEndian.PutUint32(b, arg)
		bytes = append(bytes, b...)
	}
	return bytes
}

//[]byte转化为[]uint32
func BytesToUint32s(bytes []byte) []uint32 {
	res := make([]uint32, 0)
	for i := 0; i < len(bytes)/4; i++ {
		b := bytes[4*i : 4*i+4]
		res = append(res, binary.BigEndian.Uint32(b))
	}
	return res
}
func StringToMapU32I64(str, sep1, sep2 string) map[uint32]int64 {
	res := make(map[uint32]int64)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) != 2 {
			continue
		}
		res[StringToUint32(ss2[0])] = StringToInt64(ss2[1])
	}

	return res
}
func StringToMapInt(str, first, second string) map[interface{}]int {
	data := map[interface{}]int{}
	tmp1 := strings.Split(str, first)
	for _, v := range tmp1 {
		tmp2 := strings.Split(v, second)
		if len(tmp2) != 2 {
			continue
		}
		data[tmp2[0]] = StringToInt(tmp2[1])
	}
	return data
}

func StringToMapU64U32(str, sep1, sep2 string) map[uint64]uint32 {
	res := make(map[uint64]uint32)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) != 2 {
			continue
		}

		res[StringToUint64(ss2[0])] = StringToUint32(ss2[1])
	}

	return res
}

func StringToMapUint32(str, sep1, sep2 string) map[uint32]uint32 {
	res := make(map[uint32]uint32)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) != 2 {
			continue
		}

		res[StringToUint32(ss2[0])] = StringToUint32(ss2[1])
	}

	return res
}

func StringToCalMapNum(str, sep1, sep2 string) map[uint32]uint32 {
	res := make(map[uint32]uint32)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) < 1 {
			continue
		}

		res[StringToUint32(ss2[0])] += 1
	}

	return res
}

func StringToMapKStrVUint32(str, sep1, sep2 string) map[string]uint32 {
	res := make(map[string]uint32)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) != 2 {
			continue
		}

		res[ss2[0]] = StringToUint32(ss2[1])
	}

	return res
}

func StringToMapKStrVUint64(str, sep1, sep2 string) map[string]uint64 {
	res := make(map[string]uint64)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) != 2 {
			continue
		}

		res[ss2[0]] = StringToUint64(ss2[1])
	}

	return res
}

func StringToMapKUint32VStr(str, sep1, sep2 string) map[uint32]string {
	res := make(map[uint32]string)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) != 2 {
			continue
		}

		res[StringToUint32(ss2[0])] = ss2[1]
	}

	return res
}

func StringToMapKStrVStr(str, sep1, sep2 string) map[string]string {
	res := make(map[string]string)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) != 2 {
			continue
		}

		res[ss2[0]] = ss2[1]
	}

	return res
}

func StringToMapKUint32VF32(str, sep1, sep2 string) map[uint32]float32 {
	res := make(map[uint32]float32)
	ss := strings.Split(str, sep1)
	for _, s := range ss {
		ss2 := strings.Split(s, sep2)
		if len(ss2) != 2 {
			continue
		}

		res[StringToUint32(ss2[0])] = StringToFloat32(ss2[1])
	}

	return res
}

// MapToString 奖励转换为string存储 1656:2|1657:3|1658:2
func MapToString(input map[uint64]uint32) string {
	output := ""
	for k, v := range input {
		output += strconv.FormatUint(k, 10) + ":" + strconv.FormatUint(uint64(v), 10) + "|"
	}

	return output
}

// CombineMapU64U32 用于合并两个map[uint64]uint32
func CombineMapU64U32(m1, m2 map[uint64]uint32) map[uint64]uint32 {
	if m1 == nil {
		return m2
	} else if m2 == nil {
		return m1
	}

	for k := range m1 {
		m1[k] += m2[k]
	}

	for k, v := range m2 {
		if _, ok := m1[k]; !ok {
			m1[k] = v
		}
	}

	return m1
}

func UrlValuesToMap(v url.Values) map[string]string {
	ret := make(map[string]string)
	for k := range v {
		if len(v[k]) > 0 {
			ret[k] = v[k][0]
		} else {
			ret[k] = ""
		}
	}
	return ret
}