/* Copyright 2021 Murray Inc. All Rights Reserved. */
/*
2021/10/08 11:17, by m18527, create
-----------------------------------
Go工具类，提供常用的方法
*/
package tools

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"math"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"
	"unicode"
)

func init() {
	log.SetFlags(log.Lshortfile | log.Ldate | log.Lmicroseconds)
}

type Limit struct {
	concurrency int
	channel     chan struct{}
}

func NewLimit(concurrency int) *Limit {
	return &Limit{
		concurrency: concurrency,
		channel:     make(chan struct{}, concurrency),
	}
}

func (limit *Limit) Run(f func(args ...interface{}), wGrp *sync.WaitGroup, args ...interface{}) {
	limit.channel <- struct{}{}
	wGrp.Add(1)
	go func(args ...interface{}) {
		defer func() {
			if err := recover(); err != nil {
				log.Printf("goroutine execute error, %v\n", err)
			}
		}()
		f(args...)
		wGrp.Done()
		<-limit.channel
	}(args...)
}

type KeyEnum string

func DoDoneExec(busyMap *sync.Map, key KeyEnum, f func(args ...interface{}), args ...interface{}) {
	busy, _ := busyMap.Load(key)
	if busy == false {
		busyMap.Store(key, true)
		f(args...)
		defer func() { // 执行完成
			busyMap.Store(key, false)
		}()
	}
}

func PrintStack() {
	var buf [4096]byte
	n := runtime.Stack(buf[:], false)
	log.Printf("%s\n", string(buf[:n]))
}

func PrintStackWithRecover() {
	defer func() {
		if e := recover(); e != nil {
			PrintStack()
		}
	}()
}

// 驼峰转下划线
func Camel2Case(name string) string {
	buffer := new(bytes.Buffer)
	for i, r := range name {
		if unicode.IsUpper(r) {
			if i != 0 {
				buffer.WriteString("_")
			}
			r = unicode.ToLower(r)
		}
		transVal(r, buffer)
	}
	return buffer.String()
}

func transVal(r interface{}, buffer *bytes.Buffer) {
	switch val := r.(type) {
	case int:
		buffer.WriteString(strconv.Itoa(val))
	case int64:
		buffer.WriteString(strconv.FormatInt(val, 10))
	case uint:
		buffer.WriteString(strconv.FormatUint(uint64(val), 10))
	case uint64:
		buffer.WriteString(strconv.FormatUint(val, 10))
	case string:
		buffer.WriteString(val)
	case []byte:
		buffer.Write(val)
	case rune:
		buffer.WriteRune(val)
	}
}

// 下换线转驼峰
func Case2Camel(name string) string {
	name = strings.Replace(name, "_", " ", -1)
	name = strings.Title(name)
	return strings.Replace(name, " ", "", -1)
}

// 首字母大写
func firstUpper(str string) string {
	for i, v := range str {
		return string(unicode.ToUpper(v)) + str[i+1:]
	}
	return ""
}

// 首字母小写
func firstLower(str string) string {
	for i, v := range str {
		return string(unicode.ToLower(v)) + str[i+1:]
	}
	return ""
}

// 转换字符串中的特殊字符
func SafeStr(str string) string {
	tmpStr := strings.ReplaceAll(str, `'`, ``)
	tmpStr = strings.ReplaceAll(tmpStr, `"`, `\"`)
	tmpStr = strings.ReplaceAll(tmpStr, `\`, `\\`)
	re, _ := regexp.Compile("[\\s]")
	tmpStr = re.ReplaceAllString(tmpStr, "")
	return tmpStr
}

func BuildLegalKey(args ...interface{}) string {
	fmtStr := ""
	for i := 0; i < len(args); i++ {
		fmtStr += "%v_"
	}
	fmtStr = strings.Trim(fmtStr, "_")
	tmpStr := fmt.Sprintf(fmtStr, args...)
	re, _ := regexp.Compile("[\\W]+")
	tmpStr = re.ReplaceAllString(tmpStr, "_")
	return tmpStr
}

// json str to map
func Str2Map_(jsonStr string) (result map[string]interface{}, err error) {
	err = json.Unmarshal([]byte(jsonStr), &result)
	if err != nil {
		log.Printf("%v", err)
	}
	return result, err
}
func Str2Map(jsonStr string) (result map[string]interface{}) {
	result, _ = Str2Map_(jsonStr)
	return result
}

// json str to list
func Str2List_(listStr string) (result []interface{}, err error) {
	err = json.Unmarshal([]byte(listStr), &result)
	if err != nil {
		log.Printf("%v", err)
	}
	return result, err
}
func Str2List(listStr string) (result []interface{}) {
	result, _ = Str2List_(listStr)
	return result
}

// interfaces{} to json str
func ObjToStr_(obj interface{}) (result string, err error) {
	objByte, err := json.Marshal(obj)
	if err != nil {
		log.Printf("%v", err)
	}
	result = string(objByte)
	return result, err
}
func ObjToStr(obj interface{}) (result string) {
	result, _ = ObjToStr_(obj)
	return result
}

// obj to string
func ToString(obj interface{}) string {
	if obj == nil {
		return ""
	}
	return fmt.Sprintf("%v", obj)
}

// obj to float64
func ToFloat64_(obj interface{}) (float64, error) {
	orgStr := fmt.Sprintf("%v", obj)
	valFloat, err := strconv.ParseFloat(orgStr, 64)
	if err != nil {
		log.Printf("%v", err)
	}
	return valFloat, err
}
func ToFloat64(obj interface{}) float64 {
	valFloat, _ := ToFloat64_(obj)
	return valFloat
}

// 转换为对应的数据类型， x/y保留n位小数
func ToRound_(x, y float64, n int) (float64, error) {
	fmtStr := "%." + fmt.Sprintf("%v", n) + "f"
	if y == 0 { // 排查y为0的情况
		return 0, errors.New("the dividend is 0")
	}
	valFloat, err := strconv.ParseFloat(fmt.Sprintf(fmtStr, x/y), 64)
	if err != nil {
		log.Printf("%v", err)
	}
	return valFloat, err
}
func ToRound(x, y float64, n int) float64 {
	valFloat, _ := ToRound_(x, y, n)
	return valFloat
}

// 时间字符串转时间戳
func ToTimestamp_(dateStr string) (int64, error) {
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation("2006-01-02 15:04:05", dateStr, loc)
	var sr int64
	if err != nil {
		log.Println(err)
		sr = time.Now().Unix()
	} else {
		sr = theTime.Unix()
	}
	return sr, err
}
func ToTimestamp(dateStr string) int64 {
	timestamp, _ := ToTimestamp_(dateStr)
	return timestamp
}

// timestamp to time
func Timestamp2Time(second int64) time.Time {
	tm := time.Unix(second, 0)
	return tm
}

// timestamp to time string
func Timestamp2TimeStr(second int64) string {
	tm := Timestamp2Time(second)
	return tm.Format("2006-01-02 15:04:05")
}

// 转换为对应的数据类型
func ToMap(obj interface{}) map[string]interface{} {
	if obj == nil {
		return make(map[string]interface{})
	}
	return obj.(map[string]interface{})
}

// 转换为对应的数据类型
func ToList(obj interface{}) []interface{} {
	if obj == nil {
		return []interface{}{}
	}
	return obj.([]interface{})
}

// string to int
func ToInt_(str string) (int, error) {
	val, err := strconv.Atoi(str)
	if err != nil {
		fmt.Println(err)
	}
	return val, err
}
func ToInt(str string) int {
	val, _ := ToInt_(str)
	return val
}

// string to int64
func ToInt64_(str string) (int64, error) {
	val, err := strconv.ParseInt(str, 10, 64)
	if err != nil {
		fmt.Println(err)
	}
	return val, err
}
func ToInt64(str string) int64 {
	val, _ := ToInt64_(str)
	return val
}

func Float64ToInt(f float64, isUpper bool) int {
	var val int
	if isUpper {
		val = int(math.Ceil(f))
	} else {
		val = int(math.Floor(f))
	}
	return val
}

func JsonToMap(jsonStr string) map[string]interface{} {
	_map := make(map[string]interface{})
	err := json.Unmarshal([]byte(jsonStr), &_map)
	if err != nil {
		return nil
	}
	return _map
}

func JsonToList(jsonStr string) []interface{} {
	var _list []interface{}
	err := json.Unmarshal([]byte(jsonStr), &_list)
	if err != nil {
		return nil
	}
	return _list
}

func ToJson(bean interface{}) string {
	str, err := json.Marshal(bean)
	if err != nil {
		return ""
	}
	return string(str)
}