func downloadFile(ctx context.Context, progressReporter ProgressReporter, client *http.Client, downloadURL, dstPath string, doRetries bool, buffer []byte) error {
	filePath := filepath.Base(dstPath)

	startTime := time.Now()
	ticker := time.NewTicker(250 * time.Millisecond)
	defer ticker.Stop()
	isError := false

	updateProgress := func(downloaded *int64) {
		for range ticker.C {
			if progressReporter.Cancelled() {
				break
			}
			progressReporter.UpdateDownloadProgress(*downloaded, calculateDownloadSpeed(*downloaded, startTime, time.Now()), filePath)
		}
	}

	for attempt := 1; attempt <= maxRetries; attempt++ {
		isError = false
		req, err := http.NewRequestWithContext(ctx, "GET", downloadURL, nil)
		if err != nil {
			return err
		}

		req.Header.Set("User-Agent", "WiiUDownloader")
		req.Header.Set("Connection", "Keep-Alive")
		req.Header.Set("Accept-Encoding", "")

		resp, err := client.Do(req)
		if err != nil {
			return err
		}

		if resp.StatusCode != http.StatusOK {
			if doRetries && attempt < maxRetries {
				time.Sleep(retryDelay)
				continue
			}
			resp.Body.Close()
			return fmt.Errorf("download error after %d attempts, status code: %d", attempt, resp.StatusCode)
		}

		file, err := os.Create(dstPath)
		if err != nil {
			resp.Body.Close()
			return err
		}

		var downloaded int64

		go updateProgress(&downloaded)

	Loop:
		for {
			select {
			case <-ctx.Done():
				resp.Body.Close()
				file.Close()
				return ctx.Err()
			default:
				n, err := resp.Body.Read(buffer)
				if err != nil && err != io.EOF {
					resp.Body.Close()
					file.Close()
					if doRetries && attempt < maxRetries {
						time.Sleep(retryDelay)
						isError = true
						break Loop
					}
					return fmt.Errorf("download error after %d attempts: %+v", attempt, err)
				}

				if n == 0 {
					resp.Body.Close()
					file.Close()
					break Loop
				}

				_, err = file.Write(buffer[:n])
				if err != nil {
					resp.Body.Close()
					file.Close()
					if doRetries && attempt < maxRetries {
						time.Sleep(retryDelay)
						isError = true
						break Loop
					}
					return fmt.Errorf("write error after %d attempts: %+v", attempt, err)
				}

				downloaded += int64(n)
			}
		}
		if !isError {
			break
		}
	}

	return nil
}

client := &http.Client{
		Transport: &http.Transport{
			Dial: (&net.Dialer{
				Timeout:   30 * time.Second,
				KeepAlive: 30 * time.Second,
			}).Dial,
			MaxIdleConns:          100,
			MaxIdleConnsPerHost:   100,
			MaxConnsPerHost:       100,
			IdleConnTimeout:       90 * time.Second,
			TLSHandshakeTimeout:   10 * time.Second,
			ResponseHeaderTimeout: 10 * time.Second,
			ExpectContinueTimeout: 1 * time.Second,
		},
	}