chore: seperate large files

internal/sync/srt.go

@@ -0,0 +1,100 @@
+package sync
+
+import (
+	"fmt"
+
+	"sub-cli/internal/format/srt"
+	"sub-cli/internal/model"
+)
+
+// syncSRTFiles synchronizes two SRT files
+func syncSRTFiles(sourceFile, targetFile string) error {
+	sourceEntries, err := srt.Parse(sourceFile)
+	if err != nil {
+		return fmt.Errorf("error parsing source SRT file: %w", err)
+	}
+	
+	targetEntries, err := srt.Parse(targetFile)
+	if err != nil {
+		return fmt.Errorf("error parsing target SRT file: %w", err)
+	}
+	
+	// Check if entry counts match
+	if len(sourceEntries) != len(targetEntries) {
+		fmt.Printf("Warning: Source (%d entries) and target (%d entries) have different entry counts. Timeline will be adjusted.\n", 
+			len(sourceEntries), len(targetEntries))
+	}
+	
+	// Sync the timelines
+	syncedEntries := syncSRTTimeline(sourceEntries, targetEntries)
+	
+	// Write the synced entries to the target file
+	return srt.Generate(syncedEntries, targetFile)
+}
+
+// syncSRTTimeline applies the timing from source SRT entries to target SRT entries
+func syncSRTTimeline(sourceEntries, targetEntries []model.SRTEntry) []model.SRTEntry {
+	result := make([]model.SRTEntry, len(targetEntries))
+	
+	// Copy target entries
+	copy(result, targetEntries)
+	
+	// If source is empty, just return the target entries as is
+	if len(sourceEntries) == 0 {
+		// Ensure proper sequence numbering
+		for i := range result {
+			result[i].Number = i + 1
+		}
+		return result
+	}
+	
+	// If source and target have the same number of entries, directly apply timings
+	if len(sourceEntries) == len(targetEntries) {
+		for i := range result {
+			result[i].StartTime = sourceEntries[i].StartTime
+			result[i].EndTime = sourceEntries[i].EndTime
+		}
+	} else {
+		// If entry counts differ, scale the timing
+		for i := range result {
+			// Calculate scaled index
+			sourceIdx := 0
+			if len(sourceEntries) > 1 {
+				sourceIdx = i * (len(sourceEntries) - 1) / (len(targetEntries) - 1)
+			}
+			
+			// Ensure the index is within bounds
+			if sourceIdx >= len(sourceEntries) {
+				sourceIdx = len(sourceEntries) - 1
+			}
+			
+			// Apply the scaled timing
+			result[i].StartTime = sourceEntries[sourceIdx].StartTime
+			
+			// Calculate end time: if not the last entry, use duration from source
+			if i < len(result)-1 {
+				// If next source entry exists, calculate duration
+				var duration model.Timestamp
+				if sourceIdx+1 < len(sourceEntries) {
+					duration = calculateDuration(sourceEntries[sourceIdx].StartTime, sourceEntries[sourceIdx+1].StartTime)
+				} else {
+					// If no next source entry, use the source's end time (usually a few seconds after start)
+					duration = calculateDuration(sourceEntries[sourceIdx].StartTime, sourceEntries[sourceIdx].EndTime)
+				}
+				
+				// Apply duration to next start time
+				result[i].EndTime = addDuration(result[i].StartTime, duration)
+			} else {
+				// For the last entry, add a fixed duration (e.g., 3 seconds)
+				result[i].EndTime = sourceEntries[sourceIdx].EndTime
+			}
+		}
+	}
+	
+	// Ensure proper sequence numbering
+	for i := range result {
+		result[i].Number = i + 1
+	}
+	
+	return result
+}