lots of stuff, don't truly remember

internal/ai/validator.go

@@ -0,0 +1,156 @@
+package ai
+
+import (
+	"fmt"
+	"math"
+	"time"
+)
+
+// validateWorkouts ensures AI-generated workouts meet quality standards
+func validateWorkouts(workouts []AIWorkout) error {
+	if len(workouts) == 0 {
+		return fmt.Errorf("no workouts generated")
+	}
+
+	for i, w := range workouts {
+		if err := validateWorkout(w, i); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func validateWorkout(w AIWorkout, index int) error {
+	// Required fields
+	if w.Title == "" {
+		return fmt.Errorf("workout %d: title is required", index)
+	}
+
+	if w.Duration <= 0 {
+		return fmt.Errorf("workout %d: invalid duration %d", index, w.Duration)
+	}
+
+	if w.Duration > 86400 {
+		return fmt.Errorf("workout %d: duration exceeds 24 hours", index)
+	}
+
+	// Validate date format
+	if _, err := time.Parse("2006-01-02", w.ScheduledDate); err != nil {
+		return fmt.Errorf("workout %d: invalid date format %s", index, w.ScheduledDate)
+	}
+
+	// Validate segments
+	if len(w.Segments) == 0 {
+		return fmt.Errorf("workout %d: must have at least one segment", index)
+	}
+
+	if len(w.Segments) > 100 {
+		return fmt.Errorf("workout %d: too many segments (%d), maximum 100", index, len(w.Segments))
+	}
+
+	totalDuration := 0
+	for j, seg := range w.Segments {
+		if seg.Duration <= 0 {
+			return fmt.Errorf("workout %d, segment %d: invalid duration %d", index, j, seg.Duration)
+		}
+
+		// Validate power values are reasonable (0-300% FTP)
+		if seg.Power < 0 || seg.Power > 3.0 {
+			return fmt.Errorf("workout %d, segment %d: power %.2f out of range (0-3.0)", index, j, seg.Power)
+		}
+
+		if seg.PowerLow < 0 || seg.PowerLow > 3.0 {
+			return fmt.Errorf("workout %d, segment %d: power_low %.2f out of range (0-3.0)", index, j, seg.PowerLow)
+		}
+
+		if seg.PowerHigh < 0 || seg.PowerHigh > 3.0 {
+			return fmt.Errorf("workout %d, segment %d: power_high %.2f out of range (0-3.0)", index, j, seg.PowerHigh)
+		}
+
+		// Validate that power_low <= power_high (except for ramps/cooldowns where power descends)
+		// For warmup, cooldown, and ramp types, power can go from high to low
+		if seg.PowerLow > 0 && seg.PowerHigh > 0 && seg.PowerLow > seg.PowerHigh {
+			// Allow descending power for warmup, cooldown, and ramp segments
+			if seg.Type != "warmup" && seg.Type != "cooldown" && seg.Type != "ramp" {
+				return fmt.Errorf("workout %d, segment %d: power_low (%.2f) > power_high (%.2f)", index, j, seg.PowerLow, seg.PowerHigh)
+			}
+		}
+
+		// Validate segment type
+		validTypes := map[string]bool{
+			"warmup":      true,
+			"cooldown":    true,
+			"steadystate": true,
+			"interval":    true,
+			"ramp":        true,
+			"rest":        true,
+			"freeride":    true,
+		}
+		if !validTypes[seg.Type] {
+			return fmt.Errorf("workout %d, segment %d: invalid type %s", index, j, seg.Type)
+		}
+
+		totalDuration += seg.Duration
+	}
+
+	// Verify total duration matches sum of segments (within 5% tolerance)
+	tolerance := float64(w.Duration) * 0.05
+	diff := math.Abs(float64(totalDuration - w.Duration))
+	if diff > tolerance {
+		return fmt.Errorf("workout %d: duration mismatch (declared %d, segments total %d)",
+			index, w.Duration, totalDuration)
+	}
+
+	// Validate TSS is reasonable (0-500)
+	if w.EstimatedTSS < 0 || w.EstimatedTSS > 500 {
+		return fmt.Errorf("workout %d: unrealistic TSS %.1f (expected 0-500)", index, w.EstimatedTSS)
+	}
+
+	return nil
+}
+
+// validateGenerateRequest validates user input
+func validateGenerateRequest(req GenerateRequest) error {
+	if req.PlanDuration < 1 || req.PlanDuration > 28 {
+		return fmt.Errorf("plan_duration must be between 1 and 28 days")
+	}
+
+	if req.WeeklyHours < 1 || req.WeeklyHours > 40 {
+		return fmt.Errorf("weekly_hours must be between 1 and 40")
+	}
+
+	validIntensities := map[string]bool{"easy": true, "moderate": true, "hard": true}
+	if !validIntensities[req.IntensityLevel] {
+		return fmt.Errorf("intensity_level must be 'easy', 'moderate', or 'hard'")
+	}
+
+	if len(req.FocusAreas) == 0 {
+		return fmt.Errorf("at least one focus area is required")
+	}
+
+	if len(req.FocusAreas) > 3 {
+		return fmt.Errorf("maximum 3 focus areas allowed")
+	}
+
+	validFocusAreas := map[string]bool{
+		"endurance":  true,
+		"threshold":  true,
+		"vo2max":     true,
+		"recovery":   true,
+		"sprint":     true,
+		"sweet_spot": true,
+	}
+	for _, focus := range req.FocusAreas {
+		if !validFocusAreas[focus] {
+			return fmt.Errorf("invalid focus area: %s", focus)
+		}
+	}
+
+	// Validate start date format
+	if _, err := time.Parse("2006-01-02", req.StartDate); err != nil {
+		return fmt.Errorf("invalid start_date format, use YYYY-MM-DD")
+	}
+
+	return nil
+}