Init

bot/core/download.go

@@ -0,0 +1,187 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"sort"
+	"sync"
+
+	"govd/enums"
+	"govd/models"
+	"govd/util"
+)
+
+func downloadMediaItem(
+	ctx context.Context,
+	media *models.Media,
+	config *models.DownloadConfig,
+	idx int,
+) (*models.DownloadedMedia, error) {
+	if config == nil {
+		config = util.DefaultConfig()
+	}
+
+	format := media.Format
+	if format == nil {
+		return nil, fmt.Errorf("media format is nil")
+	}
+
+	fileName := format.GetFileName()
+	var filePath string
+	var thumbnailFilePath string
+
+	if format.Type != enums.MediaTypePhoto {
+		if len(format.Segments) == 0 {
+			path, err := util.DownloadFile(
+				ctx, format.URL,
+				fileName, config,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("failed to download file: %w", err)
+			}
+			filePath = path
+		} else {
+			path, err := util.DownloadFileWithSegments(
+				ctx, format.Segments,
+				fileName, config,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("failed to download segments: %w", err)
+			}
+			filePath = path
+		}
+
+		if format.Type == enums.MediaTypeVideo || format.Type == enums.MediaTypeAudio {
+			path, err := getFileThumbnail(format, filePath)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get thumbnail: %w", err)
+			}
+			thumbnailFilePath = path
+		}
+
+		if format.Type == enums.MediaTypeVideo {
+			if format.Width == 0 || format.Height == 0 || format.Duration == 0 {
+				insertVideoInfo(format, filePath)
+			}
+		}
+	} else {
+		file, err := util.DownloadFileInMemory(ctx, format.URL, config)
+		if err != nil {
+			return nil, fmt.Errorf("failed to download image: %w", err)
+		}
+		path := filepath.Join(config.DownloadDir, fileName)
+		if err := util.ImgToJPEG(file, path); err != nil {
+			return nil, fmt.Errorf("failed to convert image: %w", err)
+		}
+		filePath = path
+	}
+
+	return &models.DownloadedMedia{
+		FilePath:          filePath,
+		ThumbnailFilePath: thumbnailFilePath,
+		Media:             media,
+		Index:             idx,
+	}, nil
+}
+
+func StartDownloadTask(
+	media *models.Media,
+	idx int,
+	config *models.DownloadConfig,
+) (*models.DownloadedMedia, error) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	return downloadMediaItem(ctx, media, config, idx)
+}
+
+func StartConcurrentDownload(
+	media *models.Media,
+	resultsChan chan<- models.DownloadedMedia,
+	config *models.DownloadConfig,
+	errChan chan<- error,
+	wg *sync.WaitGroup,
+	idx int,
+) {
+	defer wg.Done()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	result, err := downloadMediaItem(ctx, media, config, idx)
+	if err != nil {
+		errChan <- err
+		return
+	}
+
+	resultsChan <- *result
+}
+
+func DownloadMedia(
+	media *models.Media,
+	config *models.DownloadConfig,
+) (*models.DownloadedMedia, error) {
+	return StartDownloadTask(media, 0, config)
+}
+
+func DownloadMedias(
+	medias []*models.Media,
+	config *models.DownloadConfig,
+) ([]*models.DownloadedMedia, error) {
+	if len(medias) == 0 {
+		return []*models.DownloadedMedia{}, nil
+	}
+
+	if len(medias) == 1 {
+		result, err := DownloadMedia(medias[0], config)
+		if err != nil {
+			return nil, err
+		}
+		return []*models.DownloadedMedia{result}, nil
+	}
+
+	resultsChan := make(chan models.DownloadedMedia, len(medias))
+	errChan := make(chan error, len(medias))
+	var wg sync.WaitGroup
+
+	for idx, media := range medias {
+		wg.Add(1)
+		go StartConcurrentDownload(media, resultsChan, config, errChan, &wg, idx)
+	}
+
+	go func() {
+		wg.Wait()
+		close(resultsChan)
+		close(errChan)
+	}()
+
+	var results []*models.DownloadedMedia
+	var firstError error
+
+	select {
+	case err := <-errChan:
+		if err != nil {
+			firstError = err
+		}
+	default:
+		// no errors (yet)
+	}
+
+	for result := range resultsChan {
+		resultCopy := result // create a copy to avoid pointer issues
+		results = append(results, &resultCopy)
+	}
+
+	if firstError != nil {
+		return results, firstError
+	}
+
+	if len(results) > 1 {
+		sort.SliceStable(results, func(i, j int) bool {
+			return results[i].Index < results[j].Index
+		})
+	}
+
+	return results, nil
+}