validate

var BearerToken = codex.Constraint[string]{
	Name:  "bearer-token",
	Check: func(v string) bool { return v != "" && v == strings.TrimSpace(v) },
	Message: func(_ string) string {
		return "bearer token must be non-empty and contain no leading or trailing whitespace"
	},
}

var CIDR = codex.Constraint[string]{
	Name: "cidr",
	Check: func(v string) bool {
		_, _, err := net.ParseCIDR(v)
		return err == nil
	},
	Message: func(v string) string { return fmt.Sprintf("invalid CIDR notation: %q", v) },
}

var ContainerImage = codex.Constraint[string]{
	Name:    "container-image",
	Check:   func(v string) bool { return reContainerImage.MatchString(v) },
	Message: func(v string) string { return fmt.Sprintf("invalid container image reference: %q", v) },
}

var Date = codex.Constraint[string]{
	Name: "date",
	Check: func(v string) bool {
		_, err := time.Parse("2006-01-02", v)
		return err == nil
	},
	Message: func(v string) string { return fmt.Sprintf("invalid date (expected YYYY-MM-DD): %q", v) },
	Schema:  withFormat("date"),
}

var DateTime = codex.Constraint[string]{
	Name: "date-time",
	Check: func(v string) bool {
		_, err := time.Parse(time.RFC3339, v)
		if err == nil {
			return true
		}
		_, err = time.Parse(time.RFC3339Nano, v)
		return err == nil
	},
	Message: func(v string) string { return fmt.Sprintf("invalid date-time (expected RFC 3339): %q", v) },
	Schema:  withFormat("date-time"),
}

var Email = codex.Constraint[string]{
	Name:    "email",
	Check:   func(v string) bool { return reEmail.MatchString(v) },
	Message: func(v string) string { return fmt.Sprintf("invalid email address: %q", v) },
	Schema:  withFormat("email"),
}

var EnvVarName = codex.Constraint[string]{
	Name:  "envVarName",
	Check: func(v string) bool { return reEnvVar.MatchString(v) },
	Message: func(v string) string {
		return fmt.Sprintf("invalid env var name %q: must match [A-Z_][A-Z0-9_]*", v)
	},
	Schema: func(s schema.Schema) schema.Schema {
		s.Pattern = reEnvVar.String()
		return s
	},
}

var GIF = codex.Constraint[[]byte]{
	Name: "gif",
	Check: func(v []byte) bool {
		if len(v) < 6 {
			return false
		}
		return bytes.Equal(v[:6], []byte("GIF87a")) || bytes.Equal(v[:6], []byte("GIF89a"))
	},
	Message: func([]byte) string {
		return "expected GIF file: missing or invalid magic bytes (GIF87a or GIF89a)"
	},
}

var HTTPPath = codex.Constraint[string]{
	Name:  "http-path",
	Check: func(v string) bool { return httpPathRe.MatchString(v) },
	Message: func(v string) string {
		switch {
		case v == "" || v[0] != '/':
			return fmt.Sprintf("http path must start with '/', got %q", v)
		case strings.ContainsRune(v, 0):
			return fmt.Sprintf("http path must not contain null bytes, got %q", v)
		case strings.ContainsRune(v, ' '):
			return fmt.Sprintf("http path must not contain unencoded spaces, got %q", v)
		default:
			return fmt.Sprintf("invalid http path: %q", v)
		}
	},
}

var Hostname = codex.Constraint[string]{
	Name: "hostname",
	Check: func(v string) bool {
		return len(v) <= 253 && len(v) > 0 && reHostname.MatchString(v)
	},
	Message: func(v string) string { return fmt.Sprintf("invalid hostname: %q", v) },
	Schema:  withFormat("hostname"),
}

var IP = codex.Constraint[string]{
	Name:    "ip",
	Check:   func(v string) bool { return net.ParseIP(v) != nil },
	Message: func(v string) string { return fmt.Sprintf("invalid IP address: %q", v) },
	Schema:  withFormat("ip"),
}

var IPv4 = codex.Constraint[string]{
	Name: "ipv4",
	Check: func(v string) bool {
		ip := net.ParseIP(v)
		return ip != nil && ip.To4() != nil && strings.Contains(v, ".")
	},
	Message: func(v string) string { return fmt.Sprintf("invalid IPv4 address: %q", v) },
	Schema:  withFormat("ipv4"),
}

var IPv6 = codex.Constraint[string]{
	Name: "ipv6",
	Check: func(v string) bool {
		ip := net.ParseIP(v)
		return ip != nil && ip.To4() == nil
	},
	Message: func(v string) string { return fmt.Sprintf("invalid IPv6 address: %q", v) },
	Schema:  withFormat("ipv6"),
}

var IntString = codex.Constraint[string]{
	Name:    "int-string",
	Check:   func(v string) bool { _, err := strconv.Atoi(v); return err == nil },
	Message: func(v string) string { return fmt.Sprintf("expected a valid integer string, got %q", v) },
}

var JPEG = codex.Constraint[[]byte]{
	Name: "jpeg",
	Check: func(v []byte) bool {
		return len(v) >= 3 && bytes.Equal(v[:3], []byte{0xFF, 0xD8, 0xFF})
	},
	Message: func([]byte) string {
		return `expected JPEG file: missing or invalid SOI marker (\xFF\xD8\xFF)`
	},
}

var JWT = codex.Constraint[string]{
	Name:    "jwt",
	Check:   func(v string) bool { return jwtRe.MatchString(v) },
	Message: func(_ string) string { return "value must be a compact JWT (header.payload.signature in base64url)" },
}

var MQTTPublishTopic = codex.Constraint[string]{
	Name: "mqtt-publish-topic",
	Check: func(v string) bool {
		return v != "" && !strings.ContainsRune(v, 0) && len(v) <= 65535 &&
			!strings.ContainsAny(v, "+#")
	},
	Message: func(v string) string {
		switch {
		case v == "":
			return "mqtt publish topic must not be empty"
		case strings.ContainsRune(v, 0):
			return "mqtt publish topic must not contain null bytes"
		case len(v) > 65535:
			return fmt.Sprintf("mqtt publish topic exceeds maximum length of 65535 bytes, got %d", len(v))
		case strings.ContainsAny(v, "+#"):
			return fmt.Sprintf("mqtt publish topic must not contain wildcard characters '+' or '#', got %q", v)
		default:
			return fmt.Sprintf("invalid mqtt publish topic: %q", v)
		}
	},
}

var MQTTTopic = codex.Constraint[string]{
	Name: "mqtt-topic",
	Check: func(v string) bool {
		return v != "" && !strings.ContainsRune(v, 0) && utf8.RuneCountInString(v) > 0 && len(v) <= 65535
	},
	Message: func(v string) string {
		switch {
		case v == "":
			return "mqtt topic must not be empty"
		case strings.ContainsRune(v, 0):
			return "mqtt topic must not contain null bytes"
		case len(v) > 65535:
			return fmt.Sprintf("mqtt topic exceeds maximum length of 65535 bytes, got %d", len(v))
		default:
			return fmt.Sprintf("invalid mqtt topic: %q", v)
		}
	},
}

var NegativeFloat = codex.Constraint[float64]{
	Name:    "negative",
	Check:   func(v float64) bool { return v < 0 },
	Message: func(v float64) string { return fmt.Sprintf("expected negative number, got %g", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Maximum = float64ptr(0)
		s.ExclusiveMaximum = true
		return s
	},
}

var NegativeInt = codex.Constraint[int]{
	Name:    "negative",
	Check:   func(v int) bool { return v < 0 },
	Message: func(v int) string { return fmt.Sprintf("expected negative integer, got %d", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Maximum = float64ptr(0)
		s.ExclusiveMaximum = true
		return s
	},
}

var NegativeInt32 = codex.Constraint[int32]{
	Name:    "negative",
	Check:   func(v int32) bool { return v < 0 },
	Message: func(v int32) string { return fmt.Sprintf("expected negative integer, got %d", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Maximum = float64ptr(0)
		s.ExclusiveMaximum = true
		return s
	},
}

var NegativeInt64 = codex.Constraint[int64]{
	Name:    "negative",
	Check:   func(v int64) bool { return v < 0 },
	Message: func(v int64) string { return fmt.Sprintf("expected negative integer, got %d", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Maximum = float64ptr(0)
		s.ExclusiveMaximum = true
		return s
	},
}

var NonEmptyString = codex.Constraint[string]{
	Name:    "non-empty",
	Check:   func(v string) bool { return v != "" },
	Message: func(v string) string { return "expected non-empty string" },
	Schema: func(s schema.Schema) schema.Schema {
		s.MinLength = intptr(1)
		return s
	},
}

var NonNegativeDuration = codex.Constraint[time.Duration]{
	Name:    "nonNegative",
	Check:   func(v time.Duration) bool { return v >= 0 },
	Message: func(v time.Duration) string { return fmt.Sprintf("expected non-negative duration, got %s", v) },
}

var NonNegativeIntString = codex.Constraint[string]{
	Name: "non-negative-int-string",
	Check: func(v string) bool {
		n, err := strconv.Atoi(v)
		return err == nil && n >= 0
	},
	Message: func(v string) string {
		return fmt.Sprintf("expected a non-negative integer string (>= 0), got %q", v)
	},
}

var NonZeroFloat = codex.Constraint[float64]{
	Name:    "nonzero",
	Check:   func(v float64) bool { return v != 0 },
	Message: func(v float64) string { return "expected non-zero number, got 0" },
}

var NonZeroInt = codex.Constraint[int]{
	Name:    "nonzero",
	Check:   func(v int) bool { return v != 0 },
	Message: func(_ int) string { return "expected non-zero integer, got 0" },
}

var PDF = codex.Constraint[[]byte]{
	Name: "pdf",
	Check: func(v []byte) bool {
		return len(v) >= 5 && bytes.Equal(v[:5], []byte("%PDF-"))
	},
	Message: func([]byte) string {
		return "expected PDF file: missing or invalid magic bytes (%PDF-)"
	},
}

var PNG = codex.Constraint[[]byte]{
	Name: "png",
	Check: func(v []byte) bool {
		return len(v) >= 8 && bytes.Equal(v[:8], []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A})
	},
	Message: func([]byte) string {
		return `expected PNG file: missing or invalid magic bytes (\x89PNG\r\n\x1a\n)`
	},
}

var PositiveDuration = codex.Constraint[time.Duration]{
	Name:    "positive",
	Check:   func(v time.Duration) bool { return v > 0 },
	Message: func(v time.Duration) string { return fmt.Sprintf("expected positive duration, got %s", v) },
}

var PositiveFloat = codex.Constraint[float64]{
	Name:    "positive",
	Check:   func(v float64) bool { return v > 0 },
	Message: func(v float64) string { return fmt.Sprintf("expected positive number, got %g", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Minimum = float64ptr(0)
		s.ExclusiveMinimum = true
		return s
	},
}

var PositiveInt = codex.Constraint[int]{
	Name:    "positive",
	Check:   func(v int) bool { return v > 0 },
	Message: func(v int) string { return fmt.Sprintf("expected positive integer, got %d", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Minimum = float64ptr(0)
		s.ExclusiveMinimum = true
		return s
	},
}

var PositiveInt32 = codex.Constraint[int32]{
	Name:    "positive",
	Check:   func(v int32) bool { return v > 0 },
	Message: func(v int32) string { return fmt.Sprintf("expected positive integer, got %d", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Minimum = float64ptr(0)
		s.ExclusiveMinimum = true
		return s
	},
}

var PositiveInt64 = codex.Constraint[int64]{
	Name:    "positive",
	Check:   func(v int64) bool { return v > 0 },
	Message: func(v int64) string { return fmt.Sprintf("expected positive integer, got %d", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Minimum = float64ptr(0)
		s.ExclusiveMinimum = true
		return s
	},
}

var PositiveIntString = codex.Constraint[string]{
	Name: "positive-int-string",
	Check: func(v string) bool {
		n, err := strconv.Atoi(v)
		return err == nil && n > 0
	},
	Message: func(v string) string {
		return fmt.Sprintf("expected a positive integer string (> 0), got %q", v)
	},
}

var PositiveUint = codex.Constraint[uint]{
	Name:    "positive",
	Check:   func(v uint) bool { return v > 0 },
	Message: func(v uint) string { return fmt.Sprintf("expected positive integer, got %d", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Minimum = float64ptr(0)
		s.ExclusiveMinimum = true
		return s
	},
}

var PositiveUint64 = codex.Constraint[uint64]{
	Name:    "positive",
	Check:   func(v uint64) bool { return v > 0 },
	Message: func(v uint64) string { return fmt.Sprintf("expected positive integer, got %d", v) },
	Schema: func(s schema.Schema) schema.Schema {
		s.Minimum = float64ptr(0)
		s.ExclusiveMinimum = true
		return s
	},
}

var SemVer = codex.Constraint[string]{
	Name:  "semver",
	Check: func(v string) bool { return reSemVer.MatchString(v) },
	Message: func(v string) string {
		return fmt.Sprintf("invalid semantic version (expected MAJOR.MINOR.PATCH): %q", v)
	},
	Schema: func(s schema.Schema) schema.Schema {
		s.Pattern = reSemVer.String()
		return s
	},
}

var Slug = codex.Constraint[string]{
	Name:  "slug",
	Check: func(v string) bool { return reSlug.MatchString(v) },
	Message: func(v string) string {
		return fmt.Sprintf("invalid slug (lowercase alphanumeric and hyphens only): %q", v)
	},
	Schema: func(s schema.Schema) schema.Schema {
		s.Pattern = reSlug.String()
		return s
	},
}

var Time = codex.Constraint[string]{
	Name: "time",
	Check: func(v string) bool {
		dummy := "2000-01-01T" + v
		_, err := time.Parse(time.RFC3339, dummy)
		if err == nil {
			return true
		}
		_, err = time.Parse(time.RFC3339Nano, dummy)
		return err == nil
	},
	Message: func(v string) string {
		return fmt.Sprintf("invalid time (expected HH:MM:SS[.frac]Z or ±offset): %q", v)
	},
	Schema: withFormat("time"),
}

var URI = codex.Constraint[string]{
	Name: "uri",
	Check: func(v string) bool {
		u, err := url.ParseRequestURI(v)
		return err == nil && u.Scheme != "" && u.Host != ""
	},
	Message: func(v string) string { return fmt.Sprintf("invalid URI: %q", v) },
	Schema:  withFormat("uri"),
}

var URL = URLWithSchemes("http", "https")

var UUID = codex.Constraint[string]{
	Name:    "uuid",
	Check:   func(v string) bool { return reUUID.MatchString(v) },
	Message: func(v string) string { return fmt.Sprintf("invalid UUID: %q", v) },
	Schema:  withFormat("uuid"),
}

var WebP = codex.Constraint[[]byte]{
	Name: "webp",
	Check: func(v []byte) bool {
		return len(v) >= 12 &&
			bytes.Equal(v[:4], []byte("RIFF")) &&
			bytes.Equal(v[8:12], []byte("WEBP"))
	},
	Message: func([]byte) string {
		return "expected WebP file: missing or invalid RIFF/WEBP container signature"
	},
}

var ZIP = codex.Constraint[[]byte]{
	Name: "zip",
	Check: func(v []byte) bool {
		return len(v) >= 4 && bytes.Equal(v[:4], []byte{0x50, 0x4B, 0x03, 0x04})
	},
	Message: func([]byte) string {
		return `expected ZIP archive: missing or invalid local file header (PK\x03\x04)`
	},
}