package sdk

import (
	"encoding/json"
	"strconv"
	"strings"
)

func asString(v any) string {
	if v == nil {
		return ""
	}
	switch x := v.(type) {
	case string:
		return x
	case json.Number:
		return x.String()
	case []byte:
		return string(x)
	default:
		return strings.TrimSpace(fmtAny(v))
	}
}

func fmtAny(v any) string {
	b, err := json.Marshal(v)
	if err != nil {
		return ""
	}
	s := strings.Trim(string(b), `"`)
	return s
}

func asFloat(v any) float64 {
	if v == nil {
		return 0
	}
	switch x := v.(type) {
	case float64:
		return x
	case float32:
		return float64(x)
	case int:
		return float64(x)
	case int64:
		return float64(x)
	case json.Number:
		f, _ := x.Float64()
		return f
	case string:
		f, _ := strconv.ParseFloat(strings.TrimSpace(x), 64)
		return f
	default:
		f, _ := strconv.ParseFloat(asString(v), 64)
		return f
	}
}

func asInt(v any) int {
	return int(asFloat(v))
}

func asBool(v any) bool {
	switch x := v.(type) {
	case bool:
		return x
	case string:
		s := strings.ToLower(strings.TrimSpace(x))
		return s == "true" || s == "1" || s == "yes"
	default:
		return asFloat(v) != 0
	}
}

func mapField(m map[string]any, names ...string) any {
	for _, name := range names {
		if name == "" {
			continue
		}
		if v, ok := m[name]; ok && v != nil {
			return v
		}
	}
	return nil
}

func mapFieldS(m map[string]string, names ...string) string {
	for _, name := range names {
		if v, ok := m[name]; ok && strings.TrimSpace(v) != "" {
			return v
		}
	}
	return ""
}