geniusrun/backend/internal/store/laps.go

package store

import (
	"context"
	"fmt"
)

// Lap is one lap/split of an activity, from get_activity_splits, plus
// derived HR drift/recovery metrics computed from activity_samples.
type Lap struct {
	ID                  int64
	ActivityID          int64
	LapIndex            int
	StartTimeUTC        string
	DurationSeconds     float64
	DistanceMeters      float64
	AvgHR               *float64
	MaxHR               *float64
	AvgSpeedMps         *float64
	MaxSpeedMps         *float64
	ElevationGainM      *float64
	ElevationLossM      *float64
	IntensityType       string
	HRDriftBpmPerMin    *float64
	HRRecoveryBpmPerMin *float64
	// TargetPaceLowMps/High and TargetHRLowBpm/High hold the expected band
	// for this lap, resolved from the activity's structured Garmin workout
	// (see internal/sync's alignWorkoutTargets) when its steps line up 1:1
	// with the recorded laps. Nil when the activity has no structured
	// workout, the step counts don't match, or the step targets neither
	// pace nor heart rate.
	TargetPaceLowMps  *float64
	TargetPaceHighMps *float64
	TargetHRLowBpm    *float64
	TargetHRHighBpm   *float64
	RawJSON           string
}

// ReplaceLaps deletes any existing laps for activityID and inserts the given
// set, so re-syncing an activity's splits is idempotent.
func (db *DB) ReplaceLaps(ctx context.Context, activityID int64, laps []Lap) error {
	tx, err := db.BeginTx(ctx, nil)
	if err != nil {
		return fmt.Errorf("begin replace laps tx: %w", err)
	}
	defer tx.Rollback()

	if _, err := tx.ExecContext(ctx, `DELETE FROM laps WHERE activity_id = ?`, activityID); err != nil {
		return fmt.Errorf("delete existing laps for activity %d: %w", activityID, err)
	}

	for _, l := range laps {
		_, err := tx.ExecContext(ctx, `
			INSERT INTO laps (
				activity_id, lap_index, start_time_utc, duration_seconds, distance_meters,
				avg_hr, max_hr, avg_speed_mps, max_speed_mps, elevation_gain_m, elevation_loss_m,
				intensity_type, hr_drift_bpm_per_min, hr_recovery_bpm_per_min,
				target_pace_low_mps, target_pace_high_mps, target_hr_low_bpm, target_hr_high_bpm, raw_json
			) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
			activityID, l.LapIndex, l.StartTimeUTC, l.DurationSeconds, l.DistanceMeters,
			l.AvgHR, l.MaxHR, l.AvgSpeedMps, l.MaxSpeedMps, l.ElevationGainM, l.ElevationLossM,
			l.IntensityType, l.HRDriftBpmPerMin, l.HRRecoveryBpmPerMin,
			l.TargetPaceLowMps, l.TargetPaceHighMps, l.TargetHRLowBpm, l.TargetHRHighBpm, l.RawJSON,
		)
		if err != nil {
			return fmt.Errorf("insert lap %d for activity %d: %w", l.LapIndex, activityID, err)
		}
	}
	return tx.Commit()
}

// LapsForActivity returns all laps for an activity, ordered by lap_index.
func (db *DB) LapsForActivity(ctx context.Context, activityID int64) ([]Lap, error) {
	rows, err := db.QueryContext(ctx, `
		SELECT id, activity_id, lap_index, start_time_utc, duration_seconds, distance_meters,
			avg_hr, max_hr, avg_speed_mps, max_speed_mps, elevation_gain_m, elevation_loss_m,
			intensity_type, hr_drift_bpm_per_min, hr_recovery_bpm_per_min,
			target_pace_low_mps, target_pace_high_mps, target_hr_low_bpm, target_hr_high_bpm, raw_json
		FROM laps WHERE activity_id = ? ORDER BY lap_index`, activityID)
	if err != nil {
		return nil, fmt.Errorf("laps for activity %d: %w", activityID, err)
	}
	defer rows.Close()

	laps := []Lap{}
	for rows.Next() {
		var l Lap
		if err := rows.Scan(
			&l.ID, &l.ActivityID, &l.LapIndex, &l.StartTimeUTC, &l.DurationSeconds, &l.DistanceMeters,
			&l.AvgHR, &l.MaxHR, &l.AvgSpeedMps, &l.MaxSpeedMps, &l.ElevationGainM, &l.ElevationLossM,
			&l.IntensityType, &l.HRDriftBpmPerMin, &l.HRRecoveryBpmPerMin,
			&l.TargetPaceLowMps, &l.TargetPaceHighMps, &l.TargetHRLowBpm, &l.TargetHRHighBpm, &l.RawJSON,
		); err != nil {
			return nil, fmt.Errorf("scan lap row: %w", err)
		}
		laps = append(laps, l)
	}
	return laps, rows.Err()
}