chore: seperate large files

internal/sync/vtt.go

@@ -0,0 +1,104 @@
+package sync
+
+import (
+	"fmt"
+
+	"sub-cli/internal/format/vtt"
+	"sub-cli/internal/model"
+)
+
+// syncVTTFiles synchronizes two VTT files
+func syncVTTFiles(sourceFile, targetFile string) error {
+	sourceSubtitle, err := vtt.Parse(sourceFile)
+	if err != nil {
+		return fmt.Errorf("error parsing source VTT file: %w", err)
+	}
+	
+	targetSubtitle, err := vtt.Parse(targetFile)
+	if err != nil {
+		return fmt.Errorf("error parsing target VTT file: %w", err)
+	}
+	
+	// Check if entry counts match
+	if len(sourceSubtitle.Entries) != len(targetSubtitle.Entries) {
+		fmt.Printf("Warning: Source (%d entries) and target (%d entries) have different entry counts. Timeline will be adjusted.\n", 
+			len(sourceSubtitle.Entries), len(targetSubtitle.Entries))
+	}
+	
+	// Sync the timelines
+	syncedSubtitle := syncVTTTimeline(sourceSubtitle, targetSubtitle)
+	
+	// Write the synced subtitle to the target file
+	return vtt.Generate(syncedSubtitle, targetFile)
+}
+
+// syncVTTTimeline applies the timing from source VTT subtitle to target VTT subtitle
+func syncVTTTimeline(source, target model.Subtitle) model.Subtitle {
+	result := model.NewSubtitle()
+	result.Format = "vtt"
+	result.Title = target.Title
+	result.Metadata = target.Metadata
+	result.Styles = target.Styles
+	
+	// Create entries array with same length as target
+	result.Entries = make([]model.SubtitleEntry, len(target.Entries))
+	
+	// Copy target entries
+	copy(result.Entries, target.Entries)
+	
+	// If source subtitle is empty or target subtitle is empty, return copied target
+	if len(source.Entries) == 0 || len(target.Entries) == 0 {
+		// Ensure proper index numbering
+		for i := range result.Entries {
+			result.Entries[i].Index = i + 1
+		}
+		return result
+	}
+	
+	// If source and target have the same number of entries, directly apply timings
+	if len(source.Entries) == len(target.Entries) {
+		for i := range result.Entries {
+			result.Entries[i].StartTime = source.Entries[i].StartTime
+			result.Entries[i].EndTime = source.Entries[i].EndTime
+		}
+	} else {
+		// If entry counts differ, scale the timing similar to SRT sync
+		for i := range result.Entries {
+			// Calculate scaled index
+			sourceIdx := 0
+			if len(source.Entries) > 1 {
+				sourceIdx = i * (len(source.Entries) - 1) / (len(target.Entries) - 1)
+			}
+			
+			// Ensure the index is within bounds
+			if sourceIdx >= len(source.Entries) {
+				sourceIdx = len(source.Entries) - 1
+			}
+			
+			// Apply the scaled timing
+			result.Entries[i].StartTime = source.Entries[sourceIdx].StartTime
+			
+			// Calculate end time: if not the last entry, use duration from source
+			if i < len(result.Entries)-1 {
+				// If next source entry exists, calculate duration
+				var duration model.Timestamp
+				if sourceIdx+1 < len(source.Entries) {
+					duration = calculateDuration(source.Entries[sourceIdx].StartTime, source.Entries[sourceIdx+1].StartTime)
+				} else {
+					duration = calculateDuration(source.Entries[sourceIdx].StartTime, source.Entries[sourceIdx].EndTime)
+				}
+				result.Entries[i].EndTime = addDuration(result.Entries[i].StartTime, duration)
+			} else {
+				// For the last entry, use the end time from source
+				result.Entries[i].EndTime = source.Entries[sourceIdx].EndTime
+			}
+		}
+	}
+	
+	// Ensure proper index numbering
+	for i := range result.Entries {
+		result.Entries[i].Index = i + 1
+	}
+	
+	return result
+}