time.go

package check

import (
	"fmt"
	"time"
)

// TimeSchema validates time.Time values. It can also parse time strings
// using configurable layouts (defaults to RFC3339).
type TimeSchema struct {
	optional   bool
	defaultVal *time.Time
	layouts    []string // time layouts to try when parsing strings
	before     *time.Time
	after      *time.Time
	customFns  []func(time.Time) error
}

func NewTime() *TimeSchema {
	return &TimeSchema{
		layouts: []string{time.RFC3339},
	}
}

// clone returns a copy of this schema to preserve immutability in chains.
func (s *TimeSchema) clone() *TimeSchema {
	copy := *s
	if s.layouts != nil {
		copyLayouts := make([]string, len(s.layouts))
		for i, v := range s.layouts {
			copyLayouts[i] = v
		}
		copy.layouts = copyLayouts
	}
	if s.customFns != nil {
		copyCustom := make([]func(time.Time) error, len(s.customFns))
		for i, v := range s.customFns {
			copyCustom[i] = v
		}
		copy.customFns = copyCustom
	}
	return &copy
}

func (s *TimeSchema) Optional() *TimeSchema {
	s = s.clone()
	s.optional = true
	return s
}

func (s *TimeSchema) Default(v time.Time) *TimeSchema {
	s = s.clone()
	s.optional = true
	s.defaultVal = &v
	return s
}

// Layout sets the time layout(s) used when parsing strings.
// Replaces the default RFC3339. Multiple layouts are tried in order.
func (s *TimeSchema) Layout(layouts ...string) *TimeSchema {
	s = s.clone()
	s.layouts = layouts
	return s
}

// Before requires the time to be before the given time.
func (s *TimeSchema) Before(t time.Time) *TimeSchema {
	s = s.clone()
	s.before = &t
	return s
}

// After requires the time to be after the given time.
func (s *TimeSchema) After(t time.Time) *TimeSchema {
	s = s.clone()
	s.after = &t
	return s
}

// Custom adds a custom validation function.
func (s *TimeSchema) Custom(fn func(time.Time) error) *TimeSchema {
	s = s.clone()
	s.customFns = append(s.customFns, fn)
	return s
}

func (s *TimeSchema) IsOptional() bool { return s.optional }

func (s *TimeSchema) parseTime(value any) (time.Time, bool) {
	switch v := value.(type) {
	case time.Time:
		return v, true
	case string:
		for _, layout := range s.layouts {
			if t, err := time.Parse(layout, v); err == nil {
				return t, true
			}
		}
	}
	return time.Time{}, false
}

func (s *TimeSchema) Parse(value any) (any, error) {
	errs := s.Validate(value)
	if len(errs) > 0 {
		return nil, ValidationErrors(errs)
	}
	if value == nil && s.defaultVal != nil {
		return *s.defaultVal, nil
	}
	if value == nil {
		return nil, nil
	}
	t, _ := s.parseTime(value)
	return t, nil
}

func (s *TimeSchema) Validate(value any) []ValidationError {
	if value == nil {
		if s.optional {
			return nil
		}
		return []ValidationError{{Message: "required value is missing"}}
	}

	t, ok := s.parseTime(value)
	if !ok {
		return []ValidationError{{
			Message: fmt.Sprintf("expected time.Time or parseable time string, got %T", value),
			Value:   value,
		}}
	}

	var errs []ValidationError

	if s.before != nil && !t.Before(*s.before) {
		errs = append(errs, ValidationError{
			Message: fmt.Sprintf("must be before %s (got %s)", s.before.Format(time.RFC3339), t.Format(time.RFC3339)),
			Value:   t,
		})
	}

	if s.after != nil && !t.After(*s.after) {
		errs = append(errs, ValidationError{
			Message: fmt.Sprintf("must be after %s (got %s)", s.after.Format(time.RFC3339), t.Format(time.RFC3339)),
			Value:   t,
		})
	}

	for _, fn := range s.customFns {
		if err := fn(t); err != nil {
			errs = append(errs, ValidationError{Message: err.Error(), Value: t})
		}
	}

	return errs
}