431 lines
16 KiB
TypeScript
431 lines
16 KiB
TypeScript
import { useState, useEffect } from 'react';
|
|
import { WorkoutSession, WorkoutSet, ExerciseDef, ExerciseType, WorkoutPlan, Language } from '../../types';
|
|
import { getExercises, getLastSetForExercise, saveExercise, getPlans } from '../../services/storage';
|
|
import { api } from '../../services/api';
|
|
import { logSporadicSet } from '../../services/sporadicSets';
|
|
|
|
interface UseTrackerProps {
|
|
userId: string;
|
|
userWeight?: number;
|
|
activeSession: WorkoutSession | null;
|
|
activePlan: WorkoutPlan | null;
|
|
onSessionStart: (plan?: WorkoutPlan, startWeight?: number) => void;
|
|
onSessionEnd: () => void;
|
|
onSessionQuit: () => void;
|
|
onSetAdded: (set: WorkoutSet) => void;
|
|
onRemoveSet: (setId: string) => void;
|
|
onUpdateSet: (set: WorkoutSet) => void;
|
|
onSporadicSetAdded?: () => void;
|
|
}
|
|
|
|
export const useTracker = ({
|
|
userId,
|
|
userWeight,
|
|
activeSession,
|
|
activePlan,
|
|
onSessionStart,
|
|
onSessionEnd,
|
|
onSessionQuit,
|
|
onSetAdded,
|
|
onRemoveSet,
|
|
onUpdateSet,
|
|
onSporadicSetAdded
|
|
}: UseTrackerProps) => {
|
|
const [exercises, setExercises] = useState<ExerciseDef[]>([]);
|
|
const [plans, setPlans] = useState<WorkoutPlan[]>([]);
|
|
const [selectedExercise, setSelectedExercise] = useState<ExerciseDef | null>(null);
|
|
const [lastSet, setLastSet] = useState<WorkoutSet | undefined>(undefined);
|
|
const [searchQuery, setSearchQuery] = useState<string>('');
|
|
const [showSuggestions, setShowSuggestions] = useState(false);
|
|
|
|
// Timer State
|
|
const [elapsedTime, setElapsedTime] = useState<string>('00:00:00');
|
|
|
|
// Form State
|
|
const [weight, setWeight] = useState<string>('');
|
|
const [reps, setReps] = useState<string>('');
|
|
const [duration, setDuration] = useState<string>('');
|
|
const [distance, setDistance] = useState<string>('');
|
|
const [height, setHeight] = useState<string>('');
|
|
const [bwPercentage, setBwPercentage] = useState<string>('100');
|
|
|
|
// User Weight State
|
|
const [userBodyWeight, setUserBodyWeight] = useState<string>(userWeight ? userWeight.toString() : '70');
|
|
|
|
// Create Exercise State
|
|
const [isCreating, setIsCreating] = useState(false);
|
|
|
|
// Plan Execution State
|
|
const [currentStepIndex, setCurrentStepIndex] = useState(0);
|
|
const [showPlanPrep, setShowPlanPrep] = useState<WorkoutPlan | null>(null);
|
|
const [showPlanList, setShowPlanList] = useState(false);
|
|
|
|
// Confirmation State
|
|
const [showFinishConfirm, setShowFinishConfirm] = useState(false);
|
|
const [showQuitConfirm, setShowQuitConfirm] = useState(false);
|
|
const [showMenu, setShowMenu] = useState(false);
|
|
|
|
// Edit Set State
|
|
const [editingSetId, setEditingSetId] = useState<string | null>(null);
|
|
const [editWeight, setEditWeight] = useState<string>('');
|
|
const [editReps, setEditReps] = useState<string>('');
|
|
const [editDuration, setEditDuration] = useState<string>('');
|
|
const [editDistance, setEditDistance] = useState<string>('');
|
|
const [editHeight, setEditHeight] = useState<string>('');
|
|
|
|
// Sporadic Set State
|
|
const [isSporadicMode, setIsSporadicMode] = useState(false);
|
|
const [sporadicSuccess, setSporadicSuccess] = useState(false);
|
|
|
|
useEffect(() => {
|
|
const loadData = async () => {
|
|
const exList = await getExercises(userId);
|
|
exList.sort((a, b) => a.name.localeCompare(b.name));
|
|
setExercises(exList);
|
|
const planList = await getPlans(userId);
|
|
setPlans(planList);
|
|
|
|
if (activeSession?.userBodyWeight) {
|
|
setUserBodyWeight(activeSession.userBodyWeight.toString());
|
|
} else if (userWeight) {
|
|
setUserBodyWeight(userWeight.toString());
|
|
}
|
|
};
|
|
loadData();
|
|
}, [activeSession, userId, userWeight, activePlan]);
|
|
|
|
// Timer Logic
|
|
useEffect(() => {
|
|
let interval: number;
|
|
if (activeSession) {
|
|
const updateTimer = () => {
|
|
const diff = Math.floor((Date.now() - activeSession.startTime) / 1000);
|
|
const h = Math.floor(diff / 3600);
|
|
const m = Math.floor((diff % 3600) / 60);
|
|
const s = diff % 60;
|
|
setElapsedTime(`${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`);
|
|
};
|
|
|
|
updateTimer();
|
|
interval = window.setInterval(updateTimer, 1000);
|
|
}
|
|
return () => clearInterval(interval);
|
|
}, [activeSession]);
|
|
|
|
// Recalculate current step when sets change
|
|
useEffect(() => {
|
|
if (activeSession && activePlan) {
|
|
const performedCounts = new Map<string, number>();
|
|
for (const set of activeSession.sets) {
|
|
performedCounts.set(set.exerciseId, (performedCounts.get(set.exerciseId) || 0) + 1);
|
|
}
|
|
|
|
let nextStepIndex = activePlan.steps.length; // Default to finished
|
|
const plannedCounts = new Map<string, number>();
|
|
for (let i = 0; i < activePlan.steps.length; i++) {
|
|
const step = activePlan.steps[i];
|
|
const exerciseId = step.exerciseId;
|
|
plannedCounts.set(exerciseId, (plannedCounts.get(exerciseId) || 0) + 1);
|
|
const performedCount = performedCounts.get(exerciseId) || 0;
|
|
|
|
if (performedCount < plannedCounts.get(exerciseId)!) {
|
|
nextStepIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
setCurrentStepIndex(nextStepIndex);
|
|
}
|
|
}, [activeSession, activePlan]);
|
|
|
|
|
|
useEffect(() => {
|
|
if (activeSession && activePlan && exercises.length > 0 && activePlan.steps.length > 0) {
|
|
if (currentStepIndex < activePlan.steps.length) {
|
|
const step = activePlan.steps[currentStepIndex];
|
|
if (step) {
|
|
const exDef = exercises.find(e => e.id === step.exerciseId);
|
|
if (exDef) {
|
|
setSelectedExercise(exDef);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, [currentStepIndex, activePlan, exercises]);
|
|
|
|
useEffect(() => {
|
|
const updateSelection = async () => {
|
|
if (selectedExercise) {
|
|
setBwPercentage(selectedExercise.bodyWeightPercentage ? selectedExercise.bodyWeightPercentage.toString() : '100');
|
|
const set = await getLastSetForExercise(userId, selectedExercise.id);
|
|
setLastSet(set);
|
|
|
|
if (set) {
|
|
setWeight(set.weight?.toString() || '');
|
|
setReps(set.reps?.toString() || '');
|
|
setDuration(set.durationSeconds?.toString() || '');
|
|
setDistance(set.distanceMeters?.toString() || '');
|
|
setHeight(set.height?.toString() || '');
|
|
} else {
|
|
setWeight(''); setReps(''); setDuration(''); setDistance(''); setHeight('');
|
|
}
|
|
|
|
// Clear fields not relevant to the selected exercise type
|
|
if (selectedExercise.type !== ExerciseType.STRENGTH && selectedExercise.type !== ExerciseType.BODYWEIGHT) {
|
|
setWeight('');
|
|
}
|
|
if (selectedExercise.type !== ExerciseType.STRENGTH && selectedExercise.type !== ExerciseType.BODYWEIGHT && selectedExercise.type !== ExerciseType.PLYOMETRIC) {
|
|
setReps('');
|
|
}
|
|
if (selectedExercise.type !== ExerciseType.CARDIO && selectedExercise.type !== ExerciseType.STATIC) {
|
|
setDuration('');
|
|
}
|
|
if (selectedExercise.type !== ExerciseType.CARDIO && selectedExercise.type !== ExerciseType.LONG_JUMP) {
|
|
setDistance('');
|
|
}
|
|
if (selectedExercise.type !== ExerciseType.HIGH_JUMP) {
|
|
setHeight('');
|
|
}
|
|
} else {
|
|
setSearchQuery(''); // Clear search query if no exercise is selected
|
|
}
|
|
};
|
|
updateSelection();
|
|
}, [selectedExercise, userId]);
|
|
|
|
const filteredExercises = searchQuery === ''
|
|
? exercises
|
|
: exercises.filter(ex =>
|
|
ex.name.toLowerCase().includes(searchQuery.toLowerCase())
|
|
);
|
|
|
|
const handleStart = (plan?: WorkoutPlan) => {
|
|
if (plan && plan.description) {
|
|
setShowPlanPrep(plan);
|
|
} else {
|
|
onSessionStart(plan, parseFloat(userBodyWeight));
|
|
}
|
|
};
|
|
|
|
const confirmPlanStart = () => {
|
|
if (showPlanPrep) {
|
|
onSessionStart(showPlanPrep, parseFloat(userBodyWeight));
|
|
setShowPlanPrep(null);
|
|
}
|
|
}
|
|
|
|
const handleAddSet = async () => {
|
|
if (!activeSession || !selectedExercise) return;
|
|
|
|
const setData: Partial<WorkoutSet> = {
|
|
exerciseId: selectedExercise.id,
|
|
};
|
|
|
|
switch (selectedExercise.type) {
|
|
case ExerciseType.STRENGTH:
|
|
if (weight) setData.weight = parseFloat(weight);
|
|
if (reps) setData.reps = parseInt(reps);
|
|
break;
|
|
case ExerciseType.BODYWEIGHT:
|
|
if (weight) setData.weight = parseFloat(weight);
|
|
if (reps) setData.reps = parseInt(reps);
|
|
setData.bodyWeightPercentage = parseFloat(bwPercentage) || 100;
|
|
break;
|
|
case ExerciseType.CARDIO:
|
|
if (duration) setData.durationSeconds = parseInt(duration);
|
|
if (distance) setData.distanceMeters = parseFloat(distance);
|
|
break;
|
|
case ExerciseType.STATIC:
|
|
if (duration) setData.durationSeconds = parseInt(duration);
|
|
setData.bodyWeightPercentage = parseFloat(bwPercentage) || 100;
|
|
break;
|
|
case ExerciseType.HIGH_JUMP:
|
|
if (height) setData.height = parseFloat(height);
|
|
break;
|
|
case ExerciseType.LONG_JUMP:
|
|
if (distance) setData.distanceMeters = parseFloat(distance);
|
|
break;
|
|
case ExerciseType.PLYOMETRIC:
|
|
if (reps) setData.reps = parseInt(reps);
|
|
break;
|
|
}
|
|
|
|
try {
|
|
const response = await api.post('/sessions/active/log-set', setData);
|
|
if (response.success) {
|
|
const { newSet, activeExerciseId } = response;
|
|
onSetAdded(newSet);
|
|
|
|
if (activePlan && activeExerciseId) {
|
|
const nextStepIndex = activePlan.steps.findIndex(step => step.exerciseId === activeExerciseId);
|
|
if (nextStepIndex !== -1) {
|
|
setCurrentStepIndex(nextStepIndex);
|
|
}
|
|
} else if (activePlan && !activeExerciseId) {
|
|
// Plan is finished
|
|
setCurrentStepIndex(activePlan.steps.length);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error("Failed to log set:", error);
|
|
}
|
|
};
|
|
|
|
const handleLogSporadicSet = async () => {
|
|
if (!selectedExercise) return;
|
|
|
|
const set: any = {
|
|
exerciseId: selectedExercise.id,
|
|
timestamp: Date.now(),
|
|
};
|
|
|
|
switch (selectedExercise.type) {
|
|
case ExerciseType.STRENGTH:
|
|
if (weight) set.weight = parseFloat(weight);
|
|
if (reps) set.reps = parseInt(reps);
|
|
break;
|
|
case ExerciseType.BODYWEIGHT:
|
|
if (weight) set.weight = parseFloat(weight);
|
|
if (reps) set.reps = parseInt(reps);
|
|
set.bodyWeightPercentage = parseFloat(bwPercentage) || 100;
|
|
break;
|
|
case ExerciseType.CARDIO:
|
|
if (duration) set.durationSeconds = parseInt(duration);
|
|
if (distance) set.distanceMeters = parseFloat(distance);
|
|
break;
|
|
case ExerciseType.STATIC:
|
|
if (duration) set.durationSeconds = parseInt(duration);
|
|
set.bodyWeightPercentage = parseFloat(bwPercentage) || 100;
|
|
break;
|
|
case ExerciseType.HIGH_JUMP:
|
|
if (height) set.height = parseFloat(height);
|
|
break;
|
|
case ExerciseType.LONG_JUMP:
|
|
if (distance) set.distanceMeters = parseFloat(distance);
|
|
break;
|
|
case ExerciseType.PLYOMETRIC:
|
|
if (reps) set.reps = parseInt(reps);
|
|
break;
|
|
}
|
|
|
|
try {
|
|
const result = await logSporadicSet(userId, set);
|
|
if (result) {
|
|
setSporadicSuccess(true);
|
|
setTimeout(() => setSporadicSuccess(false), 2000);
|
|
// Reset form
|
|
setWeight('');
|
|
setReps('');
|
|
setDuration('');
|
|
setDistance('');
|
|
setHeight('');
|
|
if (onSporadicSetAdded) onSporadicSetAdded();
|
|
}
|
|
} catch (error) {
|
|
console.error("Failed to log sporadic set:", error);
|
|
}
|
|
};
|
|
|
|
const handleCreateExercise = async (newEx: ExerciseDef) => {
|
|
await saveExercise(userId, newEx);
|
|
setExercises(prev => [...prev, newEx].sort((a, b) => a.name.localeCompare(b.name)));
|
|
setSelectedExercise(newEx);
|
|
setIsCreating(false);
|
|
};
|
|
|
|
const handleEditSet = (set: WorkoutSet) => {
|
|
setEditingSetId(set.id);
|
|
setEditWeight(set.weight?.toString() || '');
|
|
setEditReps(set.reps?.toString() || '');
|
|
setEditDuration(set.durationSeconds?.toString() || '');
|
|
setEditDistance(set.distanceMeters?.toString() || '');
|
|
setEditHeight(set.height?.toString() || '');
|
|
};
|
|
|
|
const handleSaveEdit = (set: WorkoutSet) => {
|
|
const updatedSet: WorkoutSet = {
|
|
...set,
|
|
...(editWeight && { weight: parseFloat(editWeight) }),
|
|
...(editReps && { reps: parseInt(editReps) }),
|
|
...(editDuration && { durationSeconds: parseInt(editDuration) }),
|
|
...(editDistance && { distanceMeters: parseFloat(editDistance) }),
|
|
...(editHeight && { height: parseFloat(editHeight) })
|
|
};
|
|
onUpdateSet(updatedSet);
|
|
setEditingSetId(null);
|
|
};
|
|
|
|
const handleCancelEdit = () => {
|
|
setEditingSetId(null);
|
|
};
|
|
|
|
const jumpToStep = (index: number) => {
|
|
if (!activePlan) return;
|
|
setCurrentStepIndex(index);
|
|
setShowPlanList(false);
|
|
};
|
|
|
|
return {
|
|
exercises,
|
|
plans,
|
|
selectedExercise,
|
|
setSelectedExercise,
|
|
lastSet,
|
|
searchQuery,
|
|
setSearchQuery,
|
|
showSuggestions,
|
|
setShowSuggestions,
|
|
elapsedTime,
|
|
weight,
|
|
setWeight,
|
|
reps,
|
|
setReps,
|
|
duration,
|
|
setDuration,
|
|
distance,
|
|
setDistance,
|
|
height,
|
|
setHeight,
|
|
bwPercentage,
|
|
setBwPercentage,
|
|
userBodyWeight,
|
|
setUserBodyWeight,
|
|
isCreating,
|
|
setIsCreating,
|
|
currentStepIndex,
|
|
showPlanPrep,
|
|
setShowPlanPrep,
|
|
showPlanList,
|
|
setShowPlanList,
|
|
showFinishConfirm,
|
|
setShowFinishConfirm,
|
|
showQuitConfirm,
|
|
setShowQuitConfirm,
|
|
showMenu,
|
|
setShowMenu,
|
|
editingSetId,
|
|
editWeight,
|
|
setEditWeight,
|
|
editReps,
|
|
setEditReps,
|
|
editDuration,
|
|
setEditDuration,
|
|
editDistance,
|
|
setEditDistance,
|
|
editHeight,
|
|
setEditHeight,
|
|
isSporadicMode,
|
|
setIsSporadicMode,
|
|
sporadicSuccess,
|
|
filteredExercises,
|
|
handleStart,
|
|
confirmPlanStart,
|
|
handleAddSet,
|
|
handleLogSporadicSet,
|
|
handleCreateExercise,
|
|
handleEditSet,
|
|
handleSaveEdit,
|
|
handleCancelEdit,
|
|
jumpToStep,
|
|
};
|
|
};
|