rules.go

package govalidate

import (
	"fmt"
	"net"
	"net/url"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"time"
	"unicode"
)

// RuleFunc validates a field value and returns an error message if invalid.
// value is the field value, param is the rule parameter (e.g., "10" from "min=10").
type RuleFunc func(value reflect.Value, param string) string

// builtinRules contains all built-in validation rules.
var builtinRules = map[string]RuleFunc{
	"required":  ruleRequired,
	"min":       ruleMin,
	"max":       ruleMax,
	"len":       ruleLen,
	"email":     ruleEmail,
	"url":       ruleURL,
	"ip":        ruleIP,
	"alpha":     ruleAlpha,
	"alphanum":  ruleAlphaNum,
	"numeric":   ruleNumeric,
	"lowercase": ruleLowercase,
	"uppercase": ruleUppercase,
	"contains":  ruleContains,
	"startswith": ruleStartsWith,
	"endswith":  ruleEndsWith,
	"oneof":     ruleOneOf,
	"regex":     ruleRegex,
	"datetime":  ruleDatetime,
	"gt":        ruleGT,
	"gte":       ruleGTE,
	"lt":        ruleLT,
	"lte":       ruleLTE,
}

// ─── Required ─────────────────────────────────────────────────────

func ruleRequired(v reflect.Value, _ string) string {
	if isZero(v) {
		return "is required"
	}
	return ""
}

func isZero(v reflect.Value) bool {
	switch v.Kind() {
	case reflect.String:
		return strings.TrimSpace(v.String()) == ""
	case reflect.Bool:
		return false // bool is always "present"
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return v.Int() == 0
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return v.Uint() == 0
	case reflect.Float32, reflect.Float64:
		return v.Float() == 0
	case reflect.Slice, reflect.Map, reflect.Array:
		return v.Len() == 0
	case reflect.Ptr, reflect.Interface:
		return v.IsNil()
	default:
		return v.IsZero()
	}
}

// ─── Length / Size ────────────────────────────────────────────────

func ruleMin(v reflect.Value, param string) string {
	n, err := strconv.ParseFloat(param, 64)
	if err != nil {
		return fmt.Sprintf("invalid min parameter: %s", param)
	}

	switch v.Kind() {
	case reflect.String:
		if float64(len(v.String())) < n {
			return fmt.Sprintf("must be at least %s characters", param)
		}
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		if float64(v.Int()) < n {
			return fmt.Sprintf("must be at least %s", param)
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		if float64(v.Uint()) < n {
			return fmt.Sprintf("must be at least %s", param)
		}
	case reflect.Float32, reflect.Float64:
		if v.Float() < n {
			return fmt.Sprintf("must be at least %s", param)
		}
	case reflect.Slice, reflect.Map, reflect.Array:
		if float64(v.Len()) < n {
			return fmt.Sprintf("must have at least %s items", param)
		}
	}
	return ""
}

func ruleMax(v reflect.Value, param string) string {
	n, err := strconv.ParseFloat(param, 64)
	if err != nil {
		return fmt.Sprintf("invalid max parameter: %s", param)
	}

	switch v.Kind() {
	case reflect.String:
		if float64(len(v.String())) > n {
			return fmt.Sprintf("must be at most %s characters", param)
		}
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		if float64(v.Int()) > n {
			return fmt.Sprintf("must be at most %s", param)
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		if float64(v.Uint()) > n {
			return fmt.Sprintf("must be at most %s", param)
		}
	case reflect.Float32, reflect.Float64:
		if v.Float() > n {
			return fmt.Sprintf("must be at most %s", param)
		}
	case reflect.Slice, reflect.Map, reflect.Array:
		if float64(v.Len()) > n {
			return fmt.Sprintf("must have at most %s items", param)
		}
	}
	return ""
}

func ruleLen(v reflect.Value, param string) string {
	n, _ := strconv.Atoi(param)
	switch v.Kind() {
	case reflect.String:
		if len(v.String()) != n {
			return fmt.Sprintf("must be exactly %s characters", param)
		}
	case reflect.Slice, reflect.Map, reflect.Array:
		if v.Len() != n {
			return fmt.Sprintf("must have exactly %s items", param)
		}
	}
	return ""
}

// ─── Comparison ───────────────────────────────────────────────────

func ruleGT(v reflect.Value, param string) string {
	return compareNumeric(v, param, ">", func(a, b float64) bool { return a > b })
}

func ruleGTE(v reflect.Value, param string) string {
	return compareNumeric(v, param, ">=", func(a, b float64) bool { return a >= b })
}

func ruleLT(v reflect.Value, param string) string {
	return compareNumeric(v, param, "<", func(a, b float64) bool { return a < b })
}

func ruleLTE(v reflect.Value, param string) string {
	return compareNumeric(v, param, "<=", func(a, b float64) bool { return a <= b })
}

func compareNumeric(v reflect.Value, param, op string, cmp func(a, b float64) bool) string {
	n, err := strconv.ParseFloat(param, 64)
	if err != nil {
		return fmt.Sprintf("invalid parameter: %s", param)
	}

	var val float64
	switch v.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		val = float64(v.Int())
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		val = float64(v.Uint())
	case reflect.Float32, reflect.Float64:
		val = v.Float()
	default:
		return ""
	}

	if !cmp(val, n) {
		return fmt.Sprintf("must be %s %s", op, param)
	}
	return ""
}

// ─── Format Validators ───────────────────────────────────────────

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$`)

func ruleEmail(v reflect.Value, _ string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	if !emailRegex.MatchString(v.String()) {
		return "must be a valid email address"
	}
	return ""
}

func ruleURL(v reflect.Value, _ string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	u, err := url.ParseRequestURI(v.String())
	if err != nil || u.Scheme == "" || u.Host == "" {
		return "must be a valid URL"
	}
	return ""
}

func ruleIP(v reflect.Value, _ string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	if net.ParseIP(v.String()) == nil {
		return "must be a valid IP address"
	}
	return ""
}

// ─── String Validators ───────────────────────────────────────────

func ruleAlpha(v reflect.Value, _ string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	for _, r := range v.String() {
		if !unicode.IsLetter(r) {
			return "must contain only letters"
		}
	}
	return ""
}

func ruleAlphaNum(v reflect.Value, _ string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	for _, r := range v.String() {
		if !unicode.IsLetter(r) && !unicode.IsDigit(r) {
			return "must contain only letters and numbers"
		}
	}
	return ""
}

func ruleNumeric(v reflect.Value, _ string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	for _, r := range v.String() {
		if !unicode.IsDigit(r) && r != '.' && r != '-' {
			return "must be numeric"
		}
	}
	return ""
}

func ruleLowercase(v reflect.Value, _ string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	if v.String() != strings.ToLower(v.String()) {
		return "must be lowercase"
	}
	return ""
}

func ruleUppercase(v reflect.Value, _ string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	if v.String() != strings.ToUpper(v.String()) {
		return "must be uppercase"
	}
	return ""
}

func ruleContains(v reflect.Value, param string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	if !strings.Contains(v.String(), param) {
		return fmt.Sprintf("must contain '%s'", param)
	}
	return ""
}

func ruleStartsWith(v reflect.Value, param string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	if !strings.HasPrefix(v.String(), param) {
		return fmt.Sprintf("must start with '%s'", param)
	}
	return ""
}

func ruleEndsWith(v reflect.Value, param string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	if !strings.HasSuffix(v.String(), param) {
		return fmt.Sprintf("must end with '%s'", param)
	}
	return ""
}

func ruleOneOf(v reflect.Value, param string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	options := strings.Split(param, " ")
	for _, opt := range options {
		if v.String() == opt {
			return ""
		}
	}
	return fmt.Sprintf("must be one of: %s", strings.Join(options, ", "))
}

func ruleRegex(v reflect.Value, param string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	re, err := regexp.Compile(param)
	if err != nil {
		return fmt.Sprintf("invalid regex pattern: %s", param)
	}
	if !re.MatchString(v.String()) {
		return fmt.Sprintf("must match pattern: %s", param)
	}
	return ""
}

func ruleDatetime(v reflect.Value, param string) string {
	if v.Kind() != reflect.String {
		return ""
	}
	layout := param
	if layout == "" {
		layout = time.RFC3339
	}
	if _, err := time.Parse(layout, v.String()); err != nil {
		return fmt.Sprintf("must be a valid datetime (%s)", layout)
	}
	return ""
}