zurg/pkg/realdebrid/torrents.go

package realdebrid

import (
	"fmt"
	"net/http"
	"net/url"
	"strconv"
)

type fetchTorrentsResult struct {
	torrents []Torrent
	page     int
	total    int
	err      error
}

// GetTorrents returns all torrents, paginated
func (rd *RealDebrid) GetTorrents(onlyOne bool) ([]Torrent, int, error) {
	if onlyOne {
		result := rd.fetchPageOfTorrents(1, 1)
		if result.err != nil {
			return nil, 0, result.err
		}
		return result.torrents, result.total, nil
	}

	pageSize := 250

	firstPage := rd.fetchPageOfTorrents(1, pageSize)
	if firstPage.err != nil {
		return nil, 0, firstPage.err
	}

	totalCount := firstPage.total
	rd.log.Debugf("Torrents total count is %d", totalCount)

	for cIdx, cached := range rd.torrentsCache { // N cached torrents
		for fIdx, fresh := range firstPage.torrents { // 250 torrents in batch
			cIdxEnd := len(rd.torrentsCache) - 1 - cIdx
			fIdxEnd := totalCount - 1 - fIdx
			if fresh.ID == cached.ID && fresh.Progress == cached.Progress && fIdxEnd == cIdxEnd {
				allTorrents := firstPage.torrents[:fIdx]
				allTorrents = append(allTorrents, rd.torrentsCache[cIdx:]...)
				return allTorrents, len(allTorrents), nil
			}
		}
	}

	// Fetch all torrents in parallel

	maxPages := (totalCount + pageSize - 1) / pageSize
	resultsCh := make(chan fetchTorrentsResult, maxPages)
	for pageIdx := 2; pageIdx <= maxPages; pageIdx++ {
		pageNum := pageIdx
		rd.workerPool.Submit(func() {
			resultsCh <- rd.fetchPageOfTorrents(pageNum, pageSize)
		})
	}
	totalFetched := len(firstPage.torrents)
	torrentPages := make([][]Torrent, maxPages)
	for i := 2; i <= maxPages; i++ {
		result := <-resultsCh
		if result.err != nil {
			return nil, 0, result.err
		}
		torrentPages[result.page-1] = result.torrents
		totalFetched += len(result.torrents)
		if i%4 == 0 || i == maxPages {
			rd.log.Debugf("Got %d/%d torrents", totalFetched, result.total)
		}
	}
	allTorrents := firstPage.torrents
	for _, page := range torrentPages {
		allTorrents = append(allTorrents, page...)
	}

	rd.torrentsCache = allTorrents
	return rd.torrentsCache, len(rd.torrentsCache), nil
}

func (rd *RealDebrid) fetchPageOfTorrents(page, limit int) fetchTorrentsResult {
	baseURL := "https://api.real-debrid.com/rest/1.0/torrents"

	params := url.Values{}
	params.Set("page", fmt.Sprintf("%d", page))
	params.Set("limit", fmt.Sprintf("%d", limit))

	reqURL := baseURL + "?" + params.Encode()
	req, err := http.NewRequest(http.MethodGet, reqURL, nil)
	if err != nil {
		rd.log.Errorf("Error when creating a get torrents request: %v", err)
		return fetchTorrentsResult{
			torrents: nil,
			page:     page,
			total:    0,
			err:      err,
		}
	}

	rd.torrentsRateLimiter.Wait()

	resp, err := rd.apiClient.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the get torrents request: %v", err)
		return fetchTorrentsResult{
			torrents: nil,
			page:     page,
			total:    0,
			err:      err,
		}
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusNoContent {
		return fetchTorrentsResult{
			torrents: []Torrent{},
			page:     page,
			total:    0,
			err:      nil,
		}
	}

	if resp.StatusCode != http.StatusOK {
		err := fmt.Errorf("unexpected status code: %d", resp.StatusCode)
		rd.log.Errorf("Error when executing the get torrents request: %v", err)
		return fetchTorrentsResult{
			torrents: nil,
			page:     page,
			total:    0,
			err:      err,
		}
	}

	totalCountHeader := resp.Header.Get("x-total-count")
	totalCount, err := strconv.Atoi(totalCountHeader)
	if err != nil {
		totalCount = 0
	}

	var torrents []Torrent
	decoder := json.NewDecoder(resp.Body)
	err = decoder.Decode(&torrents)
	if err != nil {
		rd.log.Errorf("Error when decoding the body of get torrents response: %v", err)
		return fetchTorrentsResult{
			torrents: nil,
			page:     page,
			total:    0,
			err:      err,
		}
	}

	return fetchTorrentsResult{
		torrents: torrents,
		page:     page,
		total:    totalCount,
		err:      nil,
	}
}