package flags

import (
	"strconv"
	"strings"
)

type scalarValue interface {
	~bool |
		~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
		~float32 | ~float64
}

func parseScalar[T scalarValue](value string) T {
	trimmed := strings.TrimSpace(value)
	var zero T

	switch any(zero).(type) {
	case bool:
		parsed, err := strconv.ParseBool(trimmed)
		if err != nil {
			return zero
		}
		return any(parsed).(T)
	case int:
		parsed, err := strconv.ParseInt(trimmed, 0, 0)
		if err != nil {
			return zero
		}
		return any(int(parsed)).(T)
	case int8:
		parsed, err := strconv.ParseInt(trimmed, 0, 8)
		if err != nil {
			return zero
		}
		return any(int8(parsed)).(T)
	case int16:
		parsed, err := strconv.ParseInt(trimmed, 0, 16)
		if err != nil {
			return zero
		}
		return any(int16(parsed)).(T)
	case int32:
		parsed, err := strconv.ParseInt(trimmed, 0, 32)
		if err != nil {
			return zero
		}
		return any(int32(parsed)).(T)
	case int64:
		parsed, err := strconv.ParseInt(trimmed, 0, 64)
		if err != nil {
			return zero
		}
		return any(parsed).(T)
	case uint:
		parsed, err := strconv.ParseUint(trimmed, 0, 0)
		if err != nil {
			return zero
		}
		return any(uint(parsed)).(T)
	case uint8:
		parsed, err := strconv.ParseUint(trimmed, 0, 8)
		if err != nil {
			return zero
		}
		return any(uint8(parsed)).(T)
	case uint16:
		parsed, err := strconv.ParseUint(trimmed, 0, 16)
		if err != nil {
			return zero
		}
		return any(uint16(parsed)).(T)
	case uint32:
		parsed, err := strconv.ParseUint(trimmed, 0, 32)
		if err != nil {
			return zero
		}
		return any(uint32(parsed)).(T)
	case uint64:
		parsed, err := strconv.ParseUint(trimmed, 0, 64)
		if err != nil {
			return zero
		}
		return any(parsed).(T)
	case float32:
		parsed, err := strconv.ParseFloat(trimmed, 32)
		if err != nil {
			return zero
		}
		return any(float32(parsed)).(T)
	case float64:
		parsed, err := strconv.ParseFloat(trimmed, 64)
		if err != nil {
			return zero
		}
		return any(parsed).(T)
	default:
		return zero
	}
}