package utils

import (
	"fmt"
	"strconv"
	"strings"
)

// AnyToInt 任意基础类型转为int类型
func AnyToInt(value any) (int, error) {
	switch v := value.(type) {
	case int:
		return v, nil
	case int32:
		return int(v), nil
	case int64:
		return int(v), nil
	case uint:
		return int(v), nil
	case uint32:
		return int(v), nil
	case uint64:
		return int(v), nil
	case string:
		return strconv.Atoi(strings.TrimSpace(v))
	case float32:
		return int(v), nil
	case float64:
		return int(v), nil
	default:
		//fmt.Printf("Convert To Int64 : %T", v)
		return 0, fmt.Errorf("value do not convert to int")
	}
}

// AnyToInt64 任意基础类型转为int64类型
func AnyToInt64(value any) (int64, error) {
	switch v := value.(type) {
	case int:
		return int64(v), nil
	case int32:
		return int64(v), nil
	case int64:
		return v, nil
	case uint:
		return int64(v), nil
	case uint32:
		return int64(v), nil
	case uint64:
		return int64(v), nil
	case string:
		return strconv.ParseInt(strings.TrimSpace(v), 10, 64)
	case float32:
		return int64(v), nil
	case float64:
		return int64(v), nil
	default:
		//fmt.Printf("Convert To Int64 : %T", v)
		return 0, fmt.Errorf("value do not convert to int64")
	}
}

// AnyToUInt 任意基础类型转为uint类型
func AnyToUInt(value any) (uint, error) {
	switch v := value.(type) {
	case int:
		return uint(v), nil
	case int32:
		return uint(v), nil
	case int64:
		return uint(v), nil
	case uint:
		return v, nil
	case uint32:
		return uint(v), nil
	case uint64:
		return uint(v), nil
	case string:
		temp, err := strconv.ParseInt(strings.TrimSpace(v), 10, 0)
		if err != nil {
			return 0, err
		}
		return uint(temp), nil
	case float32:
		return uint(v), nil
	case float64:
		return uint(v), nil
	default:
		//fmt.Printf("Convert To Int64 : %T", v)
		return 0, fmt.Errorf("value do not convert to int64")
	}
}

// AnyToUInt32 任意基础类型转为uint32类型
func AnyToUInt32(value any) (uint32, error) {
	switch v := value.(type) {
	case int:
		return uint32(v), nil
	case int32:
		return uint32(v), nil
	case int64:
		return uint32(v), nil
	case uint:
		return uint32(v), nil
	case uint32:
		return v, nil
	case uint64:
		return uint32(v), nil
	case string:
		src, err := strconv.ParseUint(strings.TrimSpace(v), 10, 32)
		return uint32(src), err
	case float32:
		return uint32(v), nil
	case float64:
		return uint32(v), nil
	default:
		//fmt.Printf("Convert To Int64 : %T", v)
		return 0, fmt.Errorf("value do not convert to int64")
	}
}

// AnyToUInt64 任意基础类型转为uint64类型
func AnyToUInt64(value any) (uint64, error) {
	switch v := value.(type) {
	case int:
		return uint64(v), nil
	case int32:
		return uint64(v), nil
	case int64:
		return uint64(v), nil
	case uint:
		return uint64(v), nil
	case uint32:
		return uint64(v), nil
	case uint64:
		return v, nil
	case string:
		return strconv.ParseUint(strings.TrimSpace(v), 10, 64)
	case float32:
		return uint64(v), nil
	case float64:
		return uint64(v), nil
	default:
		//fmt.Printf("Convert To Int64 : %T", v)
		return 0, fmt.Errorf("value do not convert to int64")
	}
}

// AnyToString 任意基础类型转为string类型
func AnyToString(value any) (string, error) {
	switch v := value.(type) {
	case int:
		// 对于 int 整型，使用 strconv.Itoa 进行转换
		return strconv.Itoa(v), nil
	case int32:
		return strconv.Itoa(int(v)), nil
	case int64:
		// 对于 int 整型，使用 strconv.Itoa 进行转换
		return strconv.FormatInt(v, 10), nil
	case uint:
		// 对于 int 整型，使用 strconv.Itoa 进行转换
		return strconv.Itoa(int(v)), nil
	case uint32:
		return strconv.Itoa(int(v)), nil
	case uint64:
		// 对于 int 整型，使用 strconv.Itoa 进行转换
		return strconv.FormatInt(int64(v), 10), nil
	case string:
		return v, nil
	case float32:
		// 对于 float64，使用 strconv.FormatFloat 进行转换
		return strconv.FormatFloat(float64(v), 'f', -1, 32), nil
	case float64:
		// 对于 float64，使用 strconv.FormatFloat 进行转换
		return strconv.FormatFloat(v, 'f', -1, 64), nil
	default:
		// 对于其他非预期的类型，返回错误提示信息
		return "", fmt.Errorf("value do not convert to string")
	}
}

// AnyToFloat32 任意基础类型转为float32类型
func AnyToFloat32(value any) (float32, error) {
	switch v := value.(type) {
	case int:
		return float32(v), nil
	case int64:
		return float32(v), nil
	case string:
		result, err := strconv.ParseFloat(strings.TrimSpace(v), 32)
		return float32(result), err
	case float32:
		return v, nil
	case float64:
		return float32(v), nil
	default:
		return 0, fmt.Errorf("value do not convert to float32")
	}
}

// AnyToFloat64 任意基础类型转为float64类型
func AnyToFloat64(value any) (float64, error) {
	switch v := value.(type) {
	case int:
		return float64(v), nil
	case int64:
		return float64(v), nil
	case string:

		return strconv.ParseFloat(strings.TrimSpace(v), 64)
	case float32:
		return float64(v), nil
	case float64:
		return v, nil
	default:
		//fmt.Printf("Convert To Float64 : %v %T", value, v)
		return 0, fmt.Errorf("value do not convert to float64")
	}
}