validation

type CELValidator interface {
	// ValidateCEL evaluates a CEL expression against an object
	ValidateCEL(ctx context.Context, obj runtime.Object, expression string) error

	// ValidateCELValue evaluates a CEL expression against any value (for testing)
	ValidateCELValue(ctx context.Context, value interface{}, expression string) error

	// CompileCEL compiles a CEL expression for efficient reuse
	CompileCEL(expression string) (CompiledCELProgram, error)
}

type CompiledCELProgram interface {
	// Eval executes the compiled CEL expression against a value
	Eval(ctx context.Context, value interface{}) (bool, error)
}

type FieldValidator interface {
	// ValidateField validates a specific field in the object.
	// The fieldPath parameter specifies the JSON path to the field.
	ValidateField(ctx context.Context, obj runtime.Object, fieldPath string) []ValidationError

	// GetFieldValue retrieves the value of a field from an object.
	GetFieldValue(obj runtime.Object, fieldPath string) (interface{}, error)
}

type ObjectValidation struct {
	// GVK identifies the object type these validations apply to
	GVK schema.GroupVersionKind

	// Rules is a list of validation rules for this object type
	Rules []ValidationRule

	// OpenAPISchema is the OpenAPI v3 schema for additional validation (optional)
	OpenAPISchema map[string]interface{}
}

type ValidationError struct {
	// Field is the JSON path to the field that failed validation
	Field string

	// Value is the invalid value that caused the error
	Value interface{}

	// Type describes the type of validation that failed
	Type ValidationErrorType

	// Message is a human-readable error message
	Message string

	// Rule is the validation rule that was violated (optional)
	Rule string

	// Code is a machine-readable error code (optional)
	Code string
}

type ValidationErrorType string

type ValidationErrors struct {
	Errors []ValidationError
}

type ValidationManager interface {
	Validator

	// RegisterStrategy registers a validation strategy for a specific type.
	RegisterStrategy(strategy ValidationStrategy) error

	// UnregisterStrategy removes a validation strategy.
	UnregisterStrategy(strategy ValidationStrategy) error

	// HasValidationFor returns true if validation is configured for the given object type.
	HasValidationFor(obj runtime.Object) bool

	// RegisterObjectValidation registers validation rules for a specific object type.
	RegisterObjectValidation(objValidation *ObjectValidation) error
}

type ValidationOption func(*ValidationOptions)

type ValidationOptions struct {
	// FailFast stops validation on the first error if true
	FailFast bool

	// IgnoreUnknownFields ignores fields not defined in the schema
	IgnoreUnknownFields bool

	// AllowEmptyObjects allows objects with no required fields set
	AllowEmptyObjects bool

	// MaxErrors limits the number of validation errors returned
	MaxErrors int

	// Strict enables strict validation mode with additional checks
	Strict bool
}

type ValidationRule struct {
	// Field is the JSON path to the field (e.g., ".spec.name")
	Field string

	// Type is the type of validation rule
	Type ValidationRuleType

	// Value is the parameter for the validation rule (e.g., "100" for MaxLength)
	Value interface{}

	// Message is a custom error message (optional)
	Message string

	// Condition specifies when this validation should be applied (optional)
	Condition string
}

type ValidationRuleType string

type ValidationStrategy interface {
	// Execute performs validation on the object and returns validation errors.
	Execute(ctx context.Context, obj runtime.Object) []ValidationError

	// SupportsType returns true if this strategy can handle the given object type.
	SupportsType(obj runtime.Object) bool
}

type Validator interface {
	// Validate validates an object for creation or update.
	Validate(ctx context.Context, obj runtime.Object) error

	// ValidateUpdate validates an object for update, comparing with the old object.
	ValidateUpdate(ctx context.Context, obj, old runtime.Object) error

	// ValidateDelete validates an object for deletion.
	ValidateDelete(ctx context.Context, obj runtime.Object) error
}