package utils

import (
	"fmt"
	"net/http"
	"net/url"
	"reflect"
	"strings"
	"time"
	"unicode/utf8"

	"git.rosy.net.cn/baseapi"
	"github.com/satori/go.uuid"
)

func DictKeysMan(data interface{}, keysToRemove []string, keysToKeep []string) interface{} {
	if data == nil || (keysToKeep == nil && keysToRemove == nil) {
		return data
	}

	var keysToRemoveMap map[string]int
	var keysToKeepMap map[string]int
	if keysToKeep != nil {
		keysToKeepMap = make(map[string]int)
		for _, v := range keysToKeep {
			keysToKeepMap[v] = 1
		}
	} else if keysToRemove != nil {
		keysToRemoveMap = make(map[string]int)
		for _, v := range keysToRemove {
			keysToRemoveMap[v] = 1
		}
	}

	dataIsSlice := true
	valueOfData := reflect.ValueOf(data)
	if valueOfData.Kind() != reflect.Slice {
		dataIsSlice = false
		valueOfData = reflect.ValueOf([]interface{}{data})
	} else if valueOfData.Len() == 0 {
		return data
	}

	retVal := make([]interface{}, valueOfData.Len())

	for index := 0; index < valueOfData.Len(); index++ {
		realV := GetConcretValue(valueOfData.Index(index))
		if keysToRemoveMap != nil || keysToKeepMap != nil {
			mapV := make(map[string]interface{})
			for _, key := range realV.MapKeys() {
				fieldName := key.String()
				wantThisField := true
				if keysToKeepMap != nil {
					if _, ok := keysToKeepMap[fieldName]; !ok {
						wantThisField = false
					}
				} else if keysToRemoveMap != nil {
					if _, ok := keysToRemoveMap[fieldName]; ok {
						wantThisField = false
					}
				}
				if wantThisField {
					mapV[fieldName] = GetConcretValue(realV.MapIndex(key)).Interface()
				}
			}
			retVal[index] = mapV
		} else {
			retVal[index] = realV.Interface()
		}
	}

	if !dataIsSlice {
		return retVal[0]
	}
	return retVal
}

// 去除-号，全部大写，比如：929ADB626EB911E893E452540009DAB3
func GetUUID() string {
	return strings.Replace(GetUpperUUID(), "-", "", -1)
}

func GetUpperUUID() string {
	return strings.ToUpper(uuid.Must(uuid.NewV1()).String())
}

func GetCurTimeStr() string {
	return Time2Str(time.Now())
}

// timestamp is in second
func GetCurTimestamp() int64 {
	return time.Now().Unix()
}

func GetAPIOperator(userName string) string {
	retVal := "jxc4-admin"
	if userName != "" {
		retVal += "-" + userName
	}
	return retVal
}

func MergeMaps(firstMap map[string]interface{}, otherMaps ...map[string]interface{}) (retVal map[string]interface{}) {
	retVal = make(map[string]interface{})
	allMaps := append(otherMaps, firstMap)
	for _, oneMap := range allMaps {
		for k, v := range oneMap {
			retVal[k] = v
		}
	}

	return retVal
}

func CallFuncLogError(funcToCall func() error, msg string, params ...interface{}) error {
	err := funcToCall()
	if err != nil {
		baseapi.SugarLogger.Warnf("Failed "+msg+" error:%v", append(params, err.Error())...)
	}
	return err
}

func CallFuncLogErrorIgnore(funcToCall func() error, msg string, ignoreErr error, params ...interface{}) error {
	err := funcToCall()
	if err != nil && err != ignoreErr {
		baseapi.SugarLogger.Warnf("Failed "+msg+" error:%v", append(params, err.Error())...)
	}
	return err
}

func CallFuncLogErrorWithInfo(funcToCall func() error, msg string, params ...interface{}) error {
	err := funcToCall()
	if err != nil {
		baseapi.SugarLogger.Infof("Failed "+msg+" error:%v", append(params, err.Error())...)
	}
	return err
}

func CallFuncAsync(funcToCall func()) {
	go func() {
		defer func() {
			if r := recover(); r != nil {
				baseapi.SugarLogger.Errorf("error when calling func:%v, r:%v", funcToCall, r)
			}
		}()
		funcToCall()
	}()
}

func CallFuncRetryAsync(handler func(int) error, duration time.Duration, retryCount int) (err error) {
	err = handler(retryCount)
	if err != nil && retryCount > 0 {
		time.AfterFunc(duration, func() {
			CallFuncRetryAsync(handler, duration, retryCount-1)
		})
	}
	return err
}

func GenerateGetURL(baseURL, apiStr string, params map[string]interface{}) string {
	queryString := ""
	if params != nil {
		for k, v := range params {
			if queryString == "" {
				queryString = "?"
			} else {
				queryString += "&"
			}
			queryString += k + "=" + url.QueryEscape(fmt.Sprint(v))
		}
	}
	return baseURL + "/" + apiStr + queryString
}

func SendFakeRequest(method, url, body, contentType string) (*http.Response, error) {
	request, _ := http.NewRequest(method, url, strings.NewReader(body))
	if contentType == "" {
		contentType = "application/x-www-form-urlencoded"
	}
	request.Header.Set("Content-Type", contentType)
	client := &http.Client{}
	return client.Do(request)
}

// 过滤 utf8mb4（比如emoji表情）
func FilterMb4(content string) string {
	newContent := &strings.Builder{}
	for _, value := range content {
		size := utf8.RuneLen(value)
		if size >= 1 && size <= 3 {
			newContent.WriteRune(value)
		}
	}
	return newContent.String()
}

func TrimBlanChar(str string) string {
	return strings.TrimFunc(str, func(value rune) bool {
		strValue := string(value)
		return strValue == " " || strValue == "\t" || strValue == "\n" || strValue == "\r"
	})
}

func RemoveGeneralMapKeys(obj map[string]interface{}, keys ...string) map[string]interface{} {
	if obj != nil {
		for _, key := range keys {
			if _, ok := obj[key]; ok {
				delete(obj, key)
			}
		}
	}
	return obj
}