chore: seperate large files

internal/sync/utils.go

@@ -0,0 +1,136 @@
+package sync
+
+import (
+	"sub-cli/internal/model"
+)
+
+// scaleTimeline scales a timeline to match a different number of entries
+func scaleTimeline(timeline []model.Timestamp, targetCount int) []model.Timestamp {
+	if targetCount <= 0 || len(timeline) == 0 {
+		return []model.Timestamp{}
+	}
+	
+	result := make([]model.Timestamp, targetCount)
+	
+	if targetCount == 1 {
+		result[0] = timeline[0]
+		return result
+	}
+	
+	sourceLength := len(timeline)
+	
+	// Handle simple case: same length
+	if targetCount == sourceLength {
+		copy(result, timeline)
+		return result
+	}
+	
+	// Handle case where target is longer than source
+	// We need to interpolate timestamps between source entries
+	for i := 0; i < targetCount; i++ {
+		if sourceLength == 1 {
+			// If source has only one entry, use it for all target entries
+			result[i] = timeline[0]
+			continue
+		}
+		
+		// Calculate a floating-point position in the source timeline
+		floatIndex := float64(i) * float64(sourceLength-1) / float64(targetCount-1)
+		lowerIndex := int(floatIndex)
+		upperIndex := lowerIndex + 1
+		
+		// Handle boundary case
+		if upperIndex >= sourceLength {
+			upperIndex = sourceLength - 1
+			lowerIndex = upperIndex - 1
+		}
+		
+		// If indices are the same, just use the source timestamp
+		if lowerIndex == upperIndex || lowerIndex < 0 {
+			result[i] = timeline[upperIndex]
+		} else {
+			// Calculate the fraction between the lower and upper indices
+			fraction := floatIndex - float64(lowerIndex)
+			
+			// Convert timestamps to milliseconds for interpolation
+			lowerMS := timeline[lowerIndex].Hours*3600000 + timeline[lowerIndex].Minutes*60000 + 
+				timeline[lowerIndex].Seconds*1000 + timeline[lowerIndex].Milliseconds
+			
+			upperMS := timeline[upperIndex].Hours*3600000 + timeline[upperIndex].Minutes*60000 + 
+				timeline[upperIndex].Seconds*1000 + timeline[upperIndex].Milliseconds
+			
+			// Interpolate
+			resultMS := int(float64(lowerMS) + fraction*float64(upperMS-lowerMS))
+			
+			// Convert back to timestamp
+			hours := resultMS / 3600000
+			resultMS %= 3600000
+			minutes := resultMS / 60000
+			resultMS %= 60000
+			seconds := resultMS / 1000
+			milliseconds := resultMS % 1000
+			
+			result[i] = model.Timestamp{
+				Hours:        hours,
+				Minutes:      minutes,
+				Seconds:      seconds,
+				Milliseconds: milliseconds,
+			}
+		}
+	}
+	
+	return result
+}
+
+// calculateDuration calculates the time difference between two timestamps
+func calculateDuration(start, end model.Timestamp) model.Timestamp {
+	startMillis := start.Hours*3600000 + start.Minutes*60000 + start.Seconds*1000 + start.Milliseconds
+	endMillis := end.Hours*3600000 + end.Minutes*60000 + end.Seconds*1000 + end.Milliseconds
+	
+	durationMillis := endMillis - startMillis
+	if durationMillis < 0 {
+		// Return zero duration if end is before start
+		return model.Timestamp{
+			Hours:        0,
+			Minutes:      0,
+			Seconds:      0,
+			Milliseconds: 0,
+		}
+	}
+	
+	hours := durationMillis / 3600000
+	durationMillis %= 3600000
+	minutes := durationMillis / 60000
+	durationMillis %= 60000
+	seconds := durationMillis / 1000
+	milliseconds := durationMillis % 1000
+	
+	return model.Timestamp{
+		Hours:        hours,
+		Minutes:      minutes,
+		Seconds:      seconds,
+		Milliseconds: milliseconds,
+	}
+}
+
+// addDuration adds a duration to a timestamp
+func addDuration(start, duration model.Timestamp) model.Timestamp {
+	startMillis := start.Hours*3600000 + start.Minutes*60000 + start.Seconds*1000 + start.Milliseconds
+	durationMillis := duration.Hours*3600000 + duration.Minutes*60000 + duration.Seconds*1000 + duration.Milliseconds
+	
+	totalMillis := startMillis + durationMillis
+	
+	hours := totalMillis / 3600000
+	totalMillis %= 3600000
+	minutes := totalMillis / 60000
+	totalMillis %= 60000
+	seconds := totalMillis / 1000
+	milliseconds := totalMillis % 1000
+	
+	return model.Timestamp{
+		Hours:        hours,
+		Minutes:      minutes,
+		Seconds:      seconds,
+		Milliseconds: milliseconds,
+	}
+}