Robust Transcription Workflow and Cleanup in Go

package transcriber

import (
    "fmt"
    "strings"
    "whisperapp/internal/utils"
)

// TranscribeLargeMedia handles splitting, transcribing, and cleanup for a large media file.
func TranscribeLargeMedia(filePath string) (string, error) {
    var chunkPaths []string
    var transcriptions []string

    // Attempt to split the media file into chunks
    chunkPaths, err := utils.SplitMediaIntoChunks(filePath)
    if err != nil {
        return "", fmt.Errorf("failed to split media: %v", err)
    }

    // Ensure cleanup of all chunk files, even if an error occurs
    defer func() {
        for _, chunk := range chunkPaths {
            if err := utils.CleanupTempFile(chunk); err != nil {
                fmt.Printf("Warning: Could not clean up %s: %v\n", chunk, err)
            }
        }
    }()

    // Transcribe each chunk
    for _, chunk := range chunkPaths {
        text, err := Transcribe(chunk)
        if err != nil {
            fmt.Printf("Error transcribing chunk %s: %v\n", chunk, err)
            continue
        }
        transcriptions = append(transcriptions, text)
    }

    // Combine all transcriptions into a single string
    return strings.Join(transcriptions, " "), nil
}

package utils

import (
    "fmt"
    "os"
    ffmpeg_go "github.com/u2takey/ffmpeg-go"
)

// SplitMediaIntoChunks splits the media file and returns the paths to the chunk files.
// This function uses FFmpeg as shown in previous lessons.
func SplitMediaIntoChunks(filePath string) ([]string, error) {
    // For demonstration, split into 5 chunks as before
    duration, err := GetAudioDuration(filePath)
    if err != nil {
        return nil, err
    }
    chunkDuration := duration / 5
    var chunkPaths []string

    for i := 0; i < 5; i++ {
        startTime := float64(i) * chunkDuration
        chunkPath := fmt.Sprintf("/tmp/chunk_%d.mp3", i+1)
        err := ffmpeg_go.Input(filePath, ffmpeg_go.KwArgs{"ss": fmt.Sprintf("%.2f", startTime)}).
            Output(chunkPath,
                ffmpeg_go.KwArgs{
                    "t":      fmt.Sprintf("%.2f", chunkDuration),
                    "acodec": "libmp3lame",
                    "y":      "",
                },
            ).
            OverWriteOutput().
            Silent(true).
            Run()
        if err != nil {
            return chunkPaths, fmt.Errorf("encoding failed for chunk %d: %v", i+1, err)
        }
        chunkPaths = append(chunkPaths, chunkPath)
    }
    return chunkPaths, nil
}

// CleanupTempFile removes a temporary file or directory.
func CleanupTempFile(path string) error {
    info, err := os.Stat(path)
    if err != nil {
        // File may already be deleted; log and continue
        return err
    }
    if info.IsDir() {
        return os.RemoveAll(path)
    }
    return os.Remove(path)
}