feat: extend equipment and workout models with service tracking

internal/export/fit_encoder.go

@@ -0,0 +1,144 @@
+package export
+
+import (
+	"bytes"
+	"fmt"
+	"time"
+
+	"github.com/muktihari/fit/encoder"
+	"github.com/muktihari/fit/profile/filedef"
+	"github.com/muktihari/fit/profile/mesgdef"
+	"github.com/muktihari/fit/profile/typedef"
+
+	"rideaware/internal/workout"
+)
+
+// EncodeFITWorkout generates a FIT workout file from a Workout's structured segments.
+// userFTP is the user's Functional Threshold Power in watts, used to convert
+// %FTP power targets into absolute watt values for the device.
+func EncodeFITWorkout(w *workout.Workout, userFTP int) ([]byte, error) {
+	if len(w.WorkoutData.Segments) == 0 {
+		return nil, fmt.Errorf("workout has no segments")
+	}
+	if userFTP <= 0 {
+		return nil, fmt.Errorf("user FTP must be greater than 0")
+	}
+
+	wktFile := filedef.NewWorkout()
+
+	wktFile.FileId.
+		SetType(typedef.FileWorkout).
+		SetManufacturer(typedef.ManufacturerDevelopment).
+		SetProduct(1).
+		SetTimeCreated(time.Now())
+
+	name := w.WorkoutData.Name
+	if name == "" {
+		name = w.Title
+	}
+
+	wktFile.Workout = mesgdef.NewWorkout(nil).
+		SetWktName(name).
+		SetSport(typedef.SportCycling).
+		SetNumValidSteps(uint16(len(w.WorkoutData.Segments)))
+
+	steps := make([]*mesgdef.WorkoutStep, 0, len(w.WorkoutData.Segments))
+	for i, seg := range w.WorkoutData.Segments {
+		step := segmentToFITStep(seg, uint16(i), userFTP)
+		steps = append(steps, step)
+	}
+	wktFile.WorkoutSteps = steps
+
+	fit := wktFile.ToFIT(nil)
+
+	var buf bytes.Buffer
+	enc := encoder.New(&buf)
+	if err := enc.Encode(&fit); err != nil {
+		return nil, fmt.Errorf("failed to encode FIT workout: %w", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+func segmentToFITStep(seg workout.WorkoutSegment, index uint16, userFTP int) *mesgdef.WorkoutStep {
+	step := mesgdef.NewWorkoutStep(nil).
+		SetMessageIndex(typedef.MessageIndex(index)).
+		SetDurationType(typedef.WktStepDurationTime).
+		SetDurationValue(uint32(seg.Duration) * 1000) // seconds to milliseconds
+
+	switch seg.Type {
+	case "warmup":
+		step.SetIntensity(typedef.IntensityWarmup)
+		setPowerTarget(step, seg, userFTP)
+		step.SetWktStepName("Warm Up")
+
+	case "steadystate":
+		step.SetIntensity(typedef.IntensityActive)
+		setPowerTargetSteady(step, seg, userFTP)
+		step.SetWktStepName("Steady State")
+
+	case "interval":
+		step.SetIntensity(typedef.IntensityInterval)
+		setPowerTarget(step, seg, userFTP)
+		step.SetWktStepName("Interval")
+
+	case "cooldown":
+		step.SetIntensity(typedef.IntensityCooldown)
+		setPowerTarget(step, seg, userFTP)
+		step.SetWktStepName("Cool Down")
+
+	case "ramp":
+		step.SetIntensity(typedef.IntensityActive)
+		setPowerTarget(step, seg, userFTP)
+		step.SetWktStepName("Ramp")
+
+	case "freeride":
+		step.SetIntensity(typedef.IntensityActive)
+		step.SetTargetType(typedef.WktStepTargetOpen)
+		step.SetWktStepName("Free Ride")
+
+	default:
+		step.SetIntensity(typedef.IntensityActive)
+		step.SetTargetType(typedef.WktStepTargetOpen)
+	}
+
+	return step
+}
+
+// setPowerTarget sets a power range target using PowerLow/PowerHigh.
+// Values are converted from %FTP fractions to absolute watts with +1000 offset.
+func setPowerTarget(step *mesgdef.WorkoutStep, seg workout.WorkoutSegment, userFTP int) {
+	if seg.PowerLow == 0 && seg.PowerHigh == 0 && seg.Power == 0 {
+		step.SetTargetType(typedef.WktStepTargetOpen)
+		return
+	}
+
+	step.SetTargetType(typedef.WktStepTargetPower)
+	step.SetTargetValue(0) // 0 = custom range
+
+	if seg.PowerLow != 0 || seg.PowerHigh != 0 {
+		low := uint32(float64(userFTP)*seg.PowerLow) + 1000
+		high := uint32(float64(userFTP)*seg.PowerHigh) + 1000
+		step.SetCustomTargetValueLow(low)
+		step.SetCustomTargetValueHigh(high)
+	} else if seg.Power != 0 {
+		watts := uint32(float64(userFTP) * seg.Power)
+		step.SetCustomTargetValueLow(watts - 10 + 1000)
+		step.SetCustomTargetValueHigh(watts + 10 + 1000)
+	}
+}
+
+// setPowerTargetSteady sets a power target for steady state segments using the Power field.
+func setPowerTargetSteady(step *mesgdef.WorkoutStep, seg workout.WorkoutSegment, userFTP int) {
+	if seg.Power == 0 {
+		step.SetTargetType(typedef.WktStepTargetOpen)
+		return
+	}
+
+	step.SetTargetType(typedef.WktStepTargetPower)
+	step.SetTargetValue(0)
+
+	watts := uint32(float64(userFTP) * seg.Power)
+	step.SetCustomTargetValueLow(watts - 10 + 1000)
+	step.SetCustomTargetValueHigh(watts + 10 + 1000)
+}