High-Throughput Concurrent Video Downloader in Go (Goroutines & Range Headers)

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
	"sync"
)

const (
	Workers = 8
)

type DownloadJob struct {
	Index int
	Start int64
	End   int64
}

func downloadChunk(url string, job DownloadJob, wg *sync.WaitGroup, tempFiles []string) {
	defer wg.Done()

	client := &http.Client{}
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Printf("Worker %d failed to create request: %v\n", job.Index, err)
		return
	}

	req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", job.Start, job.End))
	req.Header.Set("User-Agent", "Mozilla/5.0 Go-Downloader/1.0")

	resp, err := client.Do(req)
	if err != nil || (resp.StatusCode != http.StatusPartialContent && resp.StatusCode != http.StatusOK) {
		fmt.Printf("Worker %d error: %v, status: %d\n", job.Index, err, resp.StatusCode)
		return
	}
	defer resp.Body.Close()

	tempFilename := fmt.Sprintf("chunk_%d.tmp", job.Index)
	file, err := os.Create(tempFilename)
	if err != nil {
		fmt.Printf("Worker %d file create error: %v\n", job.Index, err)
		return
	}
	defer file.Close()

	_, err = io.Copy(file, resp.Body)
	if err != nil {
		fmt.Printf("Worker %d write error: %v\n", job.Index, err)
		return
	}

	tempFiles[job.Index] = tempFilename
	fmt.Printf("Worker %d completed (%d to %d bytes)\n", job.Index, job.Start, job.End)
}

func main() {
	targetUrl := "https://example.com/sample_video.mp4"
	outputFile := "final_video.mp4"

	// 1. Send HEAD request to get total file size
	headResp, err := http.Head(targetUrl)
	if err != nil {
		panic(err)
	}
	defer headResp.Body.Close()

	contentLengthStr := headResp.Header.Get("Content-Length")
	totalSize, _ := strconv.ParseInt(contentLengthStr, 10, 64)
	fmt.Printf("Total video size: %.2f MB\n", float64(totalSize)/(1024*1024))

	chunkSize := totalSize / Workers
	var wg sync.WaitGroup
	tempFiles := make([]string, Workers)

	// 2. Launch concurrent goroutines
	for i := 0; i < Workers; i++ {
		start := int64(i) * chunkSize
		end := start + chunkSize - 1
		if i == Workers-1 {
			end = totalSize - 1
		}

		wg.Add(1)
		job := DownloadJob{Index: i, Start: start, End: end}
		go downloadChunk(targetUrl, job, &wg, tempFiles)
	}

	wg.Wait()
	fmt.Println("All chunks downloaded. Merging files...")

	// 3. Merge chunks into final MP4
	out, err := os.Create(outputFile)
	if err != nil {
		panic(err)
	}
	defer out.Close()

	for _, tempFile := range tempFiles {
		in, err := os.Open(tempFile)
		if err == nil {
			io.Copy(out, in)
			in.Close()
			os.Remove(tempFile)
		}
	}

	fmt.Printf("✅ Video successfully assembled: %s\n", outputFile)
}