utils.go

package goapi

import (
	"encoding"
	"errors"
	"fmt"
	"net/http"
	"path"
	"reflect"
	"strconv"
	"strings"

	"github.com/fatih/color"
	"github.com/golang-jwt/jwt/v5"
	"github.com/goodluckxu-go/goapi/v2/openapi"
)

func inArray[T comparable](val T, list []T) bool {
	for _, v := range list {
		if val == v {
			return true
		}
	}
	return false
}

func inArrayAny(val any, list []any) bool {
	for _, v := range list {
		if val == v {
			return true
		}
	}
	return false
}

func toPtr[T any](val T) *T {
	return &val
}

func spanFill(input string, inputLen, num int) string {
	zeroNum := num - inputLen
	var sb strings.Builder
	sb.Grow(zeroNum + len(input)) // Allocate sufficient capacity at one time
	sb.WriteString(input)
	for i := 0; i < zeroNum; i++ {
		sb.WriteString(" ")
	}
	return sb.String()
}

func addStrings(vals ...string) string {
	total := 0
	for _, s := range vals {
		total += len(s)
	}
	var sb strings.Builder
	sb.Grow(total) // Allocate sufficient capacity at one time
	for _, s := range vals {
		sb.WriteString(s)
	}
	return sb.String()
}

func allMethods() []string {
	return []string{
		http.MethodGet, MethodQuery, http.MethodPut, http.MethodPost, http.MethodDelete, http.MethodOptions, http.MethodHead,
		http.MethodPatch, http.MethodTrace,
	}
}

func pathJoin(val string, args ...string) string {
	for _, arg := range args {
		val = path.Join(val, arg)
	}
	slash := ""
	if len(args) > 0 {
		lastArg := args[len(args)-1]
		if val != "/" && len(lastArg) > 0 && lastArg[len(lastArg)-1] == '/' {
			slash = "/"
		}
	}
	return val + slash
}

func removeMorePtr(fType reflect.Type) reflect.Type {
	for fType.Kind() == reflect.Ptr && fType.Elem().Kind() == reflect.Ptr {
		fType = fType.Elem()
	}
	return fType
}

func getValueByType(fType reflect.Type, forcePtr ...bool) reflect.Value {
	var val reflect.Value
	if fType.Kind() == reflect.Ptr {
		val = reflect.New(fType.Elem())
	} else {
		if len(forcePtr) > 0 && forcePtr[0] {
			val = reflect.New(fType)
		} else {
			val = reflect.New(fType).Elem()
		}
	}
	return val
}

func getTypeByCovertInterface[Fn any](val any, forcePtr ...bool) (rType reflect.Type, ok bool) {
	switch v := val.(type) {
	case reflect.Value:
		if len(forcePtr) > 0 && forcePtr[0] && v.Kind() != reflect.Ptr {
			v = reflect.New(v.Type())
		} else {
			initPtr(v)
		}
		rType = v.Type()
		_, ok = v.Interface().(Fn)
	case reflect.Type:
		fVal := getValueByType(v, forcePtr...)
		rType = fVal.Type()
		_, ok = fVal.Interface().(Fn)
	default:
		rType = reflect.TypeOf(val)
		_, ok = val.(Fn)
	}
	return
}

func getFnByCovertInterface[Fn any](val any, forcePtr ...bool) (fn Fn, ok bool) {
	switch v := val.(type) {
	case reflect.Value:
		if len(forcePtr) > 0 && forcePtr[0] && v.Kind() != reflect.Ptr {
			v = reflect.New(v.Type())
		}
		fn, ok = v.Interface().(Fn)
	case reflect.Type:
		fVal := getValueByType(v, forcePtr...)
		fn, ok = fVal.Interface().(Fn)
	default:
		fn, ok = val.(Fn)
	}
	return
}

func coverInterfaceByValue[T any](fVal reflect.Value, fn func(fn T) error, forcePtr ...bool) (err error) {
	if len(forcePtr) > 0 && forcePtr[0] && fVal.Kind() != reflect.Ptr {
		newVal := reflect.New(fVal.Type())
		if t, ok := newVal.Interface().(T); ok {
			if err = fn(t); err != nil {
				return
			}
			fVal.Set(newVal.Elem())
		}
		return
	}
	initPtr(fVal)
	if t, ok := fVal.Interface().(T); ok {
		if err = fn(t); err != nil {
			return
		}
	}
	return
}

func initPtr(fVal reflect.Value) {
	if fVal.Kind() != reflect.Ptr || !fVal.IsNil() {
		return
	}
	newVal := reflect.New(fVal.Type().Elem())
	fVal.Set(newVal)
}

func isArrayType(fType reflect.Type, fn func(sType reflect.Type) bool, deeps ...int) bool {
	deep := -1
	if len(deeps) > 0 {
		deep = deeps[0]
	}
	for {
		if deep == 0 {
			return false
		}
		if deep > 0 {
			deep--
		}
		fType = removeMorePtr(fType)
		if fn(fType) {
			return true
		}
		if fType.Kind() == reflect.Ptr {
			fType = fType.Elem()
			if fn(fType) {
				return true
			}
		}
		if inArray(fType.Kind(), []reflect.Kind{reflect.Array, reflect.Slice}) {
			return isArrayType(fType.Elem(), fn, deep)
		}
		return false
	}
}

func isNormalType(fType reflect.Type) bool {
	if isNumberType(fType) {
		return true
	}
	switch fType.Kind() {
	case reflect.Bool, reflect.String:
		return true
	default:
	}
	return false
}

func isNumberType(fType reflect.Type) bool {
	switch fType.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8,
		reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
		return true
	default:
	}
	return false
}

func toString(v any) string {
	switch val := v.(type) {
	case int:
		return strconv.FormatInt(int64(val), 10)
	case int8:
		return strconv.FormatInt(int64(val), 10)
	case int16:
		return strconv.FormatInt(int64(val), 10)
	case int32:
		return strconv.FormatInt(int64(val), 10)
	case int64:
		return strconv.FormatInt(val, 10)
	case uint:
		return strconv.FormatUint(uint64(val), 10)
	case uint8:
		return strconv.FormatUint(uint64(val), 10)
	case uint16:
		return strconv.FormatUint(uint64(val), 10)
	case uint32:
		return strconv.FormatUint(uint64(val), 10)
	case uint64:
		return strconv.FormatUint(val, 10)
	case float32:
		return strconv.FormatFloat(float64(val), 'f', -1, 32)
	case float64:
		return strconv.FormatFloat(val, 'f', -1, 64)
	case bool:
		return strconv.FormatBool(val)
	case string:
		return val
	}
	return fmt.Sprintf("%v", v)
}

func mergePathTags(tags []string, args []string) (list []string) {
	list = make([]string, 0, len(tags)+len(args))
	for _, tag := range tags {
		if inArray(tag, list) {
			continue
		}
		list = append(list, tag)
	}
	for _, arg := range args {
		if inArray(arg, list) {
			continue
		}
		list = append(list, arg)
	}
	return
}

func mergeOpenAPITags(tags []*openapi.Tag, args []*openapi.Tag) (list []*openapi.Tag) {
	var tagStrs []string
	for _, tag := range tags {
		if inArray(tag.Name, tagStrs) {
			continue
		}
		tagStrs = append(tagStrs, tag.Name)
		list = append(list, tag)
	}
	for _, tag := range args {
		if inArray(tag.Name, tagStrs) {
			continue
		}
		tagStrs = append(tagStrs, tag.Name)
		list = append(list, tag)
	}
	return
}

// decryptJWT encrypted string based on JWT encryption
func decryptJWT(j *JWT, jwtStr string, bearerJWT HTTPBearerJWT) error {
	pToken, err := jwt.Parse(jwtStr, func(token *jwt.Token) (interface{}, error) {
		return bearerJWT.DecryptKey()
	}, jwt.WithValidMethods([]string{bearerJWT.SigningMethod().Alg()}))
	if err != nil {
		return err
	}
	if !pToken.Valid {
		return fmt.Errorf("invalid token")
	}
	mapClaims, ok := pToken.Claims.(jwt.MapClaims)
	if !ok {
		return fmt.Errorf("invalid claims")
	}
	j.Subject, _ = mapClaims.GetSubject()
	j.Issuer, _ = mapClaims.GetIssuer()
	j.Audience, _ = mapClaims.GetAudience()
	if exp, _ := mapClaims.GetExpirationTime(); exp != nil {
		j.ExpiresAt = exp.Time
	}
	if nbf, _ := mapClaims.GetNotBefore(); nbf != nil {
		j.NotBefore = nbf.Time
	}
	if iat, _ := mapClaims.GetIssuedAt(); iat != nil {
		j.IssuedAt = iat.Time
	}
	if jti, _ := mapClaims["jti"].(string); jti != "" {
		j.ID = jti
	}
	j.Extensions = map[string]any{}
	for k, v := range mapClaims {
		if inArray(k, []string{"iss", "sub", "aud", "exp", "nbf", "iat", "jti"}) {
			continue
		}
		j.Extensions[k] = v
	}
	return nil
}

// Inherit ‘encoding.TextMarshaler’ and ‘encoding.TextUnmarshaler’
func isTextInterface(val any) (ok bool) {
	switch v := val.(type) {
	case reflect.Value:
		if _, ok = v.Interface().(encoding.TextMarshaler); !ok {
			return
		}
		if v.Kind() != reflect.Ptr {
			v = reflect.New(v.Type())
		}
		_, ok = v.Interface().(encoding.TextUnmarshaler)
	case reflect.Type:
		var ptrVal reflect.Value
		if v.Kind() != reflect.Ptr {
			ptrVal = reflect.New(v)
			if _, ok = ptrVal.Elem().Interface().(encoding.TextMarshaler); !ok {
				return
			}
		} else {
			ptrVal = reflect.New(v.Elem())
			if _, ok = ptrVal.Interface().(encoding.TextMarshaler); !ok {
				return
			}
		}
		_, ok = ptrVal.Interface().(encoding.TextUnmarshaler)
	default:
	}
	return
}

func toFirstUpper(s string) string {
	if len(s) == 0 {
		return s
	}
	runes := []rune(s)
	runes[0] &= -33
	for i := 1; i < len(runes); i++ {
		runes[i] |= 32
	}
	return string(runes)
}

func valueSet(dst, src reflect.Value) (isSet bool) {
	if !dst.CanSet() {
		return
	}
	if src.Kind() == reflect.Interface {
		src = src.Elem()
	}
	dstType := dst.Type()
	srcType := src.Type()
	if dstType == srcType {
		dst.Set(src)
		isSet = true
		return
	}
	if srcType.ConvertibleTo(dstType) {
		dst.Set(src.Convert(dstType))
		isSet = true
		return
	}
	if dst.Kind() != reflect.Ptr && src.Kind() != reflect.Ptr {
		return
	}
	for src.Kind() == reflect.Ptr {
		if src.IsNil() {
			return
		}
		src = src.Elem()
	}
	for dst.Kind() == reflect.Ptr {
		initPtr(dst)
		dst = dst.Elem()
	}
	return valueSet(dst, src)
}

func defaultSet(dst reflect.Value, _default any) (isSet bool) {
	if _default == nil {
		return
	}
	dVal := reflect.ValueOf(_default)
	if dVal.IsZero() {
		return
	}
	for dVal.Kind() == reflect.Ptr {
		if dVal.IsNil() {
			return
		}
		dVal = dVal.Elem()
	}
	for dst.Kind() == reflect.Ptr {
		initPtr(dst)
		dst = dst.Elem()
	}
	switch dVal.Kind() {
	case reflect.Array, reflect.Slice:
		dValLen := dVal.Len()
		if dValLen == 0 {
			return
		}
		var newValue reflect.Value
		if dst.Kind() == reflect.Slice {
			newValue = reflect.MakeSlice(dst.Type(), dValLen, dValLen)
		} else {
			newValue = reflect.New(dst.Type()).Elem()
		}
		for i := 0; i < newValue.Len(); i++ {
			if i < dValLen {
				if !valueSet(newValue.Index(i), dVal.Index(i)) {
					return
				}
			}
		}
		dst.Set(newValue)
		isSet = true
	default:
		isSet = valueSet(dst, dVal)
	}
	return
}

func getHTTPError(err error, defaultCode int) error {
	switch val := err.(type) {
	case *HTTPError:
		return val
	}
	var maxBytesErr *http.MaxBytesError
	if errors.As(err, &maxBytesErr) {
		return NewHTTPError(http.StatusRequestEntityTooLarge, err.Error())
	}
	return NewHTTPError(defaultCode, err.Error())
}

func ColorInfo(a ...any) string {
	if Colorful {
		return color.New(color.FgGreen).SprintFunc()(a...)
	}
	return fmt.Sprint(a...)
}

func ColorDebug(a ...any) string {
	if Colorful {
		return color.New(color.FgCyan).SprintFunc()(a...)
	}
	return fmt.Sprint(a...)
}

func ColorWarning(a ...any) string {
	if Colorful {
		return color.New(color.FgHiYellow).SprintFunc()(a...)
	}
	return fmt.Sprint(a...)
}

func ColorError(a ...any) string {
	if Colorful {
		return color.New(color.FgRed).SprintFunc()(a...)
	}
	return fmt.Sprint(a...)
}

func ColorFatal(a ...any) string {
	if Colorful {
		return color.New(color.BgRed, color.FgWhite).SprintFunc()(a...)
	}
	return fmt.Sprint(a...)
}