Function bodies 285 total

    private User getUser(Authentication authentication) {
        String email = authentication.getName();
        return userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
    }

public class NutritionController {

    private final NutritionService nutritionService;
    private final UserRepository userRepository;

    public NutritionController(NutritionService nutritionService, UserRepository userRepository) {
        this.nutritionService = nutritionService;
        this.userRepository = userRepository;
    }

    @GetMapping("/targets")
    @Operation(summary = "Get nutrition targets", description = "Returns the user's current nutrition plan with macro targets")
    public ResponseEntity<NutritionPlanResponse> getTargets(Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(nutritionService.getTargets(userId));
    }

    @PostMapping("/log")
    @Operation(summary = "Log nutrition", description = "Logs a nutrition entry with calories and macro breakdown")
    public ResponseEntity<Map<String, Object>> logNutrition(
            @Valid @RequestBody NutritionLogRequest request,
            Authenti

    public NutritionController(NutritionService nutritionService, UserRepository userRepository) {
        this.nutritionService = nutritionService;
        this.userRepository = userRepository;
    }

    public ResponseEntity<NutritionPlanResponse> getTargets(Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(nutritionService.getTargets(userId));
    }

    public ResponseEntity<Map<String, Object>> logNutrition(
            @Valid @RequestBody NutritionLogRequest request,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        NutritionLog log = nutritionService.logNutrition(userId, request);

        Map<String, Object> result = new LinkedHashMap<>();
        result.put("message", "Nutrition logged successfully");
        result.put("logId", log.getId());
        result.put("logDate", log.getLogDate().toString());
        return ResponseEntity.status(HttpStatus.CREATED).body(result);
    }

    public ResponseEntity<List<NutritionLog>> getHistory(Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(nutritionService.getHistory(userId));
    }

    private Long getUserId(Authentication authentication) {
        String email = authentication.getName();
        User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
        return user.getId();
    }

public class OnboardingController {

    private final OnboardingService onboardingService;
    private final UserRepository userRepository;
    private final UserProfileRepository userProfileRepository;

    public OnboardingController(OnboardingService onboardingService, UserRepository userRepository,
                                UserProfileRepository userProfileRepository) {
        this.onboardingService = onboardingService;
        this.userRepository = userRepository;
        this.userProfileRepository = userProfileRepository;
    }

    @PostMapping("/submit")
    @Operation(summary = "Submit onboarding", description = "Submits the user's onboarding profile and generates an initial workout plan")
    public ResponseEntity<Map<String, Object>> submitOnboarding(
            @Valid @RequestBody OnboardingRequest request,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        WorkoutPlan workoutPlan = onboardingService.submitOnboardi

    public OnboardingController(OnboardingService onboardingService, UserRepository userRepository,
                                UserProfileRepository userProfileRepository) {
        this.onboardingService = onboardingService;
        this.userRepository = userRepository;
        this.userProfileRepository = userProfileRepository;
    }

    public ResponseEntity<Map<String, Object>> submitOnboarding(
            @Valid @RequestBody OnboardingRequest request,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        WorkoutPlan workoutPlan = onboardingService.submitOnboarding(userId, request);

        return ResponseEntity.status(HttpStatus.CREATED).body(Map.of(
                "message", "Onboarding completed successfully",
                "workoutDays", workoutPlan.getWorkoutDays().size(),
                "daysPerWeek", workoutPlan.getDaysPerWeek()
        ));
    }

    public ResponseEntity<Map<String, Boolean>> getOnboardingStatus(Authentication authentication) {
        Long userId = getUserId(authentication);
        boolean completed = onboardingService.getOnboardingStatus(userId);
        return ResponseEntity.ok(Map.of("completed", completed));
    }

    public ResponseEntity<Map<String, Object>> getProfile(Authentication authentication) {
        Long userId = getUserId(authentication);
        UserProfile profile = userProfileRepository.findByUserId(userId)
                .orElseThrow(() -> new ResourceNotFoundException("Profile not found"));

        Map<String, Object> data = new LinkedHashMap<>();
        data.put("fitnessGoal", profile.getFitnessGoal());
        data.put("experienceLevel", profile.getExperienceLevel());
        data.put("daysPerWeek", profile.getDaysPerWeek());
        data.put("sessionDurationMinutes", profile.getSessionDurationMinutes());
        data.put("equipmentAccess", profile.getEquipmentAccess());
        data.put("dietaryPreference", profile.getDietaryPreference());
        data.put("heightCm", profile.getHeightCm());
        data.put("weightKg", profile.getWeightKg());
        data.put("age", profile.getAge());
        data.put("goalDurationWeeks", profile.getGoalDurationWeeks());

        return 

    public ResponseEntity<Map<String, String>> updateProfile(
            @Valid @RequestBody OnboardingRequest request,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        UserProfile profile = userProfileRepository.findByUserId(userId)
                .orElseThrow(() -> new ResourceNotFoundException("Profile not found"));

        profile.setFitnessGoal(request.getFitnessGoal());
        profile.setExperienceLevel(request.getExperienceLevel());
        profile.setDaysPerWeek(request.getDaysPerWeek());
        profile.setSessionDurationMinutes(request.getSessionDurationMinutes());
        profile.setEquipmentAccess(request.getEquipmentAccess());
        profile.setDietaryPreference(request.getDietaryPreference());
        profile.setHeightCm(request.getHeightCm());
        profile.setWeightKg(request.getWeightKg());
        profile.setAge(request.getAge());
        profile.setGoalDurationWeeks(request.getGoalDurationWeeks());
        u

    private Long getUserId(Authentication authentication) {
        String email = authentication.getName();
        User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
        return user.getId();
    }

public class ProgressController {

    private final ProgressService progressService;
    private final UserRepository userRepository;

    public ProgressController(ProgressService progressService, UserRepository userRepository) {
        this.progressService = progressService;
        this.userRepository = userRepository;
    }

    @GetMapping("/dashboard")
    @Operation(summary = "Get dashboard", description = "Returns summary dashboard data including adherence, streaks, and recent activity")
    public ResponseEntity<DashboardResponse> getDashboard(Authentication authentication) {
        Long userId = getUserId(authentication);
        DashboardResponse dashboard = progressService.getDashboard(userId);
        return ResponseEntity.ok(dashboard);
    }

    @GetMapping("/export")
    @Operation(summary = "Export progress data", description = "Returns weight trend, weekly adherence, and plan history for charts")
    public ResponseEntity<ProgressResponse> exportProgress(Authentic

    public ProgressController(ProgressService progressService, UserRepository userRepository) {
        this.progressService = progressService;
        this.userRepository = userRepository;
    }

    public ResponseEntity<DashboardResponse> getDashboard(Authentication authentication) {
        Long userId = getUserId(authentication);
        DashboardResponse dashboard = progressService.getDashboard(userId);
        return ResponseEntity.ok(dashboard);
    }

    public ResponseEntity<ProgressResponse> exportProgress(Authentication authentication) {
        Long userId = getUserId(authentication);
        ProgressResponse progress = progressService.getProgressData(userId);
        return ResponseEntity.ok(progress);
    }

    private Long getUserId(Authentication authentication) {
        String email = authentication.getName();
        User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
        return user.getId();
    }

public class SavedSplitController {

    private final SavedSplitRepository savedSplitRepository;
    private final UserRepository userRepository;
    private final ObjectMapper objectMapper;

    public SavedSplitController(SavedSplitRepository savedSplitRepository,
                                UserRepository userRepository,
                                ObjectMapper objectMapper) {
        this.savedSplitRepository = savedSplitRepository;
        this.userRepository = userRepository;
        this.objectMapper = objectMapper;
    }

    @GetMapping
    @Operation(summary = "List saved splits", description = "Returns all saved workout splits for the authenticated user")
    public ResponseEntity<List<SavedSplit>> listSavedSplits(Authentication authentication) {
        User user = getUser(authentication);
        List<SavedSplit> splits = savedSplitRepository.findByUserOrderByCreatedAtDesc(user);
        return ResponseEntity.ok(splits);
    }

    @PostMapping
    @Operation(summ

    public SavedSplitController(SavedSplitRepository savedSplitRepository,
                                UserRepository userRepository,
                                ObjectMapper objectMapper) {
        this.savedSplitRepository = savedSplitRepository;
        this.userRepository = userRepository;
        this.objectMapper = objectMapper;
    }

    public ResponseEntity<List<SavedSplit>> listSavedSplits(Authentication authentication) {
        User user = getUser(authentication);
        List<SavedSplit> splits = savedSplitRepository.findByUserOrderByCreatedAtDesc(user);
        return ResponseEntity.ok(splits);
    }

    public ResponseEntity<SavedSplit> createSavedSplit(
            @RequestBody Map<String, Object> body,
            Authentication authentication) {
        User user = getUser(authentication);

        SavedSplit split = new SavedSplit();
        split.setUser(user);
        split.setName((String) body.get("name"));

        Object days = body.get("days");
        if (days instanceof String) {
            split.setDays((String) days);
        } else {
            try {
                split.setDays(objectMapper.writeValueAsString(days));
            } catch (JsonProcessingException e) {
                throw new com.adaptivefit.exception.BadRequestException("Invalid days JSON");
            }
        }

        SavedSplit saved = savedSplitRepository.save(split);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }

    public ResponseEntity<Map<String, String>> deleteSavedSplit(
            @PathVariable Long id,
            Authentication authentication) {
        User user = getUser(authentication);
        SavedSplit split = savedSplitRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("Saved split not found"));

        if (!split.getUser().getId().equals(user.getId())) {
            throw new ResourceNotFoundException("Saved split not found");
        }

        savedSplitRepository.delete(split);
        return ResponseEntity.ok(Map.of("message", "Saved split deleted successfully"));
    }

    private User getUser(Authentication authentication) {
        String email = authentication.getName();
        return userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
    }

public class WorkoutController {

    private final WorkoutService workoutService;
    private final UserRepository userRepository;

    public WorkoutController(WorkoutService workoutService, UserRepository userRepository) {
        this.workoutService = workoutService;
        this.userRepository = userRepository;
    }

    @GetMapping("/week")
    @Operation(summary = "Get weekly schedule", description = "Returns the current week's workout schedule with day details")
    public ResponseEntity<Map<String, Object>> getWeeklySchedule(Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(workoutService.getWeeklySchedule(userId));
    }

    @GetMapping("/day/{dayId}")
    @Operation(summary = "Get day detail", description = "Returns detailed exercises for a specific workout day")
    public ResponseEntity<Map<String, Object>> getDayDetail(
            @PathVariable Long dayId,
            Authentication authentication) {
    

    public WorkoutController(WorkoutService workoutService, UserRepository userRepository) {
        this.workoutService = workoutService;
        this.userRepository = userRepository;
    }

    public ResponseEntity<Map<String, Object>> getWeeklySchedule(Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(workoutService.getWeeklySchedule(userId));
    }

    public ResponseEntity<Map<String, Object>> getDayDetail(
            @PathVariable Long dayId,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(workoutService.getDayDetail(userId, dayId));
    }

    public ResponseEntity<Map<String, Object>> completeWorkout(
            @Valid @RequestBody WorkoutLogRequest request,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(workoutService.completeWorkout(userId, request));
    }

    public ResponseEntity<List<Map<String, Object>>> getAlternativeExercises(
            @PathVariable Long exerciseId,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(workoutService.getAlternativeExercises(userId, exerciseId));
    }

    public ResponseEntity<Map<String, Object>> substituteExercise(
            @Valid @RequestBody SubstituteExerciseRequest request,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        return ResponseEntity.ok(workoutService.substituteExercise(userId, request));
    }

    private Long getUserId(Authentication authentication) {
        String email = authentication.getName();
        User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
        return user.getId();
    }

public class WorkoutPlanController {

    private final WorkoutPlanRepository workoutPlanRepository;
    private final UserRepository userRepository;

    public WorkoutPlanController(WorkoutPlanRepository workoutPlanRepository, UserRepository userRepository) {
        this.workoutPlanRepository = workoutPlanRepository;
        this.userRepository = userRepository;
    }

    @GetMapping("/current")
    @Operation(summary = "Get current plan", description = "Returns the user's currently active workout plan")
    public ResponseEntity<WorkoutPlanResponse> getCurrentPlan(Authentication authentication) {
        Long userId = getUserId(authentication);
        WorkoutPlan plan = workoutPlanRepository.findByUserIdAndStatus(userId, PlanStatus.ACTIVE)
                .orElseThrow(() -> new ResourceNotFoundException("No active workout plan found"));
        return ResponseEntity.ok(WorkoutPlanResponse.fromEntity(plan));
    }

    @GetMapping("/history")
    @Operation(summary = "Get plan his

    public WorkoutPlanController(WorkoutPlanRepository workoutPlanRepository, UserRepository userRepository) {
        this.workoutPlanRepository = workoutPlanRepository;
        this.userRepository = userRepository;
    }

    public ResponseEntity<WorkoutPlanResponse> getCurrentPlan(Authentication authentication) {
        Long userId = getUserId(authentication);
        WorkoutPlan plan = workoutPlanRepository.findByUserIdAndStatus(userId, PlanStatus.ACTIVE)
                .orElseThrow(() -> new ResourceNotFoundException("No active workout plan found"));
        return ResponseEntity.ok(WorkoutPlanResponse.fromEntity(plan));
    }

    public ResponseEntity<List<WorkoutPlanResponse>> getPlanHistory(Authentication authentication) {
        Long userId = getUserId(authentication);
        List<WorkoutPlan> plans = workoutPlanRepository.findByUserIdOrderByVersionDesc(userId);
        List<WorkoutPlanResponse> responses = plans.stream()
                .map(WorkoutPlanResponse::fromEntity)
                .toList();
        return ResponseEntity.ok(responses);
    }

    public ResponseEntity<WorkoutPlanResponse> getPlanById(
            @PathVariable Long planId,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        WorkoutPlan plan = workoutPlanRepository.findById(planId)
                .orElseThrow(() -> new ResourceNotFoundException("Workout plan not found"));
        if (!plan.getUserId().equals(userId)) {
            throw new ResourceNotFoundException("Workout plan not found");
        }
        return ResponseEntity.ok(WorkoutPlanResponse.fromEntity(plan));
    }

    public ResponseEntity<Map<String, Object>> updateRoutine(
            @RequestBody Map<String, Object> body,
            Authentication authentication) {
        Long userId = getUserId(authentication);
        WorkoutPlan plan = workoutPlanRepository.findByUserIdAndStatus(userId, PlanStatus.ACTIVE)
                .orElseThrow(() -> new ResourceNotFoundException("No active workout plan found"));

        Object routineObj = body.get("workoutRoutine");
        if (!(routineObj instanceof List)) {
            throw new BadRequestException("workoutRoutine must be an array");
        }

        List<Map<String, Object>> routine = (List<Map<String, Object>>) routineObj;

        // Clear existing days (cascade will remove exercises)
        plan.getWorkoutDays().clear();

        // Create new days and exercises from the routine
        for (Map<String, Object> dayData : routine) {
            WorkoutDay day = new WorkoutDay();
            day.setWorkoutPlan(plan);
            day.setD

    public ResponseEntity<List<Map<String, Object>>> getPresets() {
        List<Map<String, Object>> presets = List.of(
                Map.of("key", "ppl", "name", "Push / Pull / Legs", "description", "Classic 3-day split", "days", 3),
                Map.of("key", "upper_lower", "name", "Upper / Lower", "description", "4-day upper lower split", "days", 4),
                Map.of("key", "full_body", "name", "Full Body", "description", "3 full body sessions", "days", 3),
                Map.of("key", "bro_split", "name", "Bro Split", "description", "5-day bodypart split", "days", 5)
        );

        return ResponseEntity.ok(presets);
    }

    public ResponseEntity<Map<String, Object>> generateFromPreset(
            @RequestBody Map<String, String> body,
            Authentication authentication) {
        // Validate user is authenticated
        getUserId(authentication);

        String presetKey = body.get("presetKey");
        String equipment = body.getOrDefault("equipment", "gym");
        String goal = body.getOrDefault("goal", "general");

        if (presetKey == null) {
            throw new BadRequestException("presetKey is required");
        }

        List<Map<String, Object>> workoutRoutine = generatePresetRoutine(presetKey, equipment, goal);

        Map<String, Object> response = new LinkedHashMap<>();
        response.put("presetKey", presetKey);
        response.put("equipment", equipment);
        response.put("goal", goal);
        response.put("workoutRoutine", workoutRoutine);

        return ResponseEntity.ok(response);
    }

    private List<Map<String, Object>> generatePresetRoutine(String presetKey, String equipment, String goal) {
        return switch (presetKey) {
            case "ppl" -> List.of(
                    buildDay(1, "Push", "push", List.of(
                            buildExercise("Bench Press", "Chest", 4, 8),
                            buildExercise("Overhead Press", "Shoulders", 3, 10),
                            buildExercise("Incline Dumbbell Press", "Chest", 3, 10),
                            buildExercise("Lateral Raises", "Shoulders", 3, 15),
                            buildExercise("Tricep Pushdowns", "Triceps", 3, 12)
                    )),
                    buildDay(2, "Pull", "pull", List.of(
                            buildExercise("Barbell Rows", "Back", 4, 8),
                            buildExercise("Pull-Ups", "Back", 3, 8),
                            buildExercise("Face Pulls", "Rear Delts", 3, 15),
                            buildExercise("Barbell Curls", "

    private Map<String, Object> buildDay(int day, String title, String splitType, List<Map<String, Object>> exercises) {
        Map<String, Object> dayMap = new LinkedHashMap<>();
        dayMap.put("day", day);
        dayMap.put("title", title);
        dayMap.put("splitType", splitType);
        dayMap.put("exercises", exercises);
        return dayMap;
    }

    private Map<String, Object> buildExercise(String name, String muscleGroup, int sets, int reps) {
        Map<String, Object> exercise = new LinkedHashMap<>();
        exercise.put("name", name);
        exercise.put("muscleGroup", muscleGroup);
        exercise.put("sets", sets);
        exercise.put("reps", reps);
        return exercise;
    }

    private Long getUserId(Authentication authentication) {
        String email = authentication.getName();
        User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
        return user.getId();
    }

    private int toInt(Object value) {
        if (value instanceof Integer) {
            return (Integer) value;
        }
        if (value instanceof Number) {
            return ((Number) value).intValue();
        }
        return Integer.parseInt(String.valueOf(value));
    }

public class ChangePasswordRequest {

    @NotBlank(message = "Current password is required")
    private String currentPassword;

    @NotBlank(message = "New password is required")
    @Size(min = 8, message = "New password must be at least 8 characters")
    private String newPassword;
}

public class CheckInRequest {

    @NotNull
    @Min(1)
    private Integer weekNumber;

    @NotNull
    @Min(0)
    private Integer sessionsCompleted;

    @NotNull
    @Min(1)
    @Max(5)
    private Integer difficultyRating;

    private BigDecimal currentWeightKg;

    private String notes;
}

public class ExtraWorkoutRequest {

    private List<ExerciseEntry> exercises;

    @Getter
    @Setter
    public static class ExerciseEntry {
        private String name;
        private Integer sets;
        private String reps;
        private BigDecimal weightKg;
    }
}

    public static class ExerciseEntry {
        private String name;
        private Integer sets;
        private String reps;
        private BigDecimal weightKg;
    }