debrid

type Account struct {
	User    string
	Premium bool
	Expires time.Time
}

type AcquireRequest struct {
	InfoHash string
	Magnet   string
	// TorrentID reuses a torrent already on the account ("" adds anew).
	TorrentID string
	// Choose picks the wanted file; providers that select files (Real-Debrid)
	// call it before selection.
	Choose         func([]File) (File, error)
	CachedOnly     bool
	RemoveUncached bool
	// MayRemove, when set, is asked before a torrent this call added is
	// removed again (RemoveUncached); false keeps it on the account because
	// a cluster node is streaming from it.
	MayRemove func(ctx context.Context, torrentID string) bool
}

type Acquired struct {
	TorrentID string
	File      File
	// Added reports whether this call added the torrent to the account.
	Added bool
}

type DirectLink struct {
	URL     string
	Size    int64
	Expires time.Time
}

type Engine struct {
	// contains filtered or unexported fields
}

type EngineOptions struct {
	// Inner serves every non-debrid payload (the Usenet stream engine).
	Inner core.Engine
	// Health checks non-debrid payloads; nil when Inner does not implement
	// core.HealthChecker.
	Health core.HealthChecker
	// Cache stores fetched blocks on disk (nil keeps them in memory only).
	Cache core.SegmentCache
	// HTTPClient and HedgeClient read media; they must use separate
	// connection pools so a hedged request opens a fresh connection.
	HTTPClient  *http.Client
	HedgeClient *http.Client
	Logger      *slog.Logger
	Now         func() time.Time
	HedgeDelay  time.Duration // 0 = 400ms; negative disables hedging
	BlockSize   int64         // tests; 0 = 512 KiB
}

type EngineStats struct {
	OpenFiles     int   `json:"openFiles"`
	BlockBytes    int64 `json:"blockBytes"`
	MemoryHits    int64 `json:"memoryHits"`
	DiskHits      int64 `json:"diskHits"`
	BlocksFetched int64 `json:"blocksFetched"`
	BytesFetched  int64 `json:"bytesFetched"`
	Hedges        int64 `json:"hedges"`
	HedgeWins     int64 `json:"hedgeWins"`
	LinkRefreshes int64 `json:"linkRefreshes"`
	Errors        int64 `json:"errors"`
}

type File struct {
	ID   string // provider file id ("" when the provider has none)
	Path string
	Size int64
	// Link is the provider-side link for the file (Real-Debrid hoster
	// link, AllDebrid file link, Premiumize, Debrid-Link and Offcloud
	// direct link).
	Link string
	// contains filtered or unexported fields
}

type Handle struct {
	TorrentID, FileID, Path, Link, Magnet, InfoHash string
	Size                                            int64
}

type Indexer struct {
	// contains filtered or unexported fields
}

type Latency struct {
	ResolveMs     float64 `json:"resolveMs"`
	LinkMs        float64 `json:"linkMs"`
	ConnectMs     float64 `json:"connectMs"`
	TTFBMs        float64 `json:"ttfbMs"`
	ThroughputBps float64 `json:"throughputBps"`
	Samples       int64   `json:"samples"`
}

type Options struct {
	DB     *sql.DB // nil keeps state in memory
	Logger *slog.Logger
	Now    func() time.Time
	// Provider options (tests point them at httptest servers).
	ProviderOptions ProviderOptions
	// NewProvider overrides provider construction (tests).
	NewProvider func(config.DebridProvider, ProviderOptions) (Provider, error)
	PayloadTTL  time.Duration // stored payload reuse, 0 = 7 days
	CachedTTL   time.Duration // known-cached memory, 0 = 12h
	UncachedTTL time.Duration // known-uncached memory, 0 = 30m
	// DirectGuard guards direct HTTP stream requests (tests map fake public
	// hosts onto local servers); nil uses a zero safefetch.Guard.
	DirectGuard *safefetch.Guard
}

type Payload struct {
	Key       string              `json:"key,omitempty"`       // payload cache key (release + target)
	ReleaseID string              `json:"releaseId,omitempty"` // core.Release.ID (segment cache key)
	Provider  string              `json:"provider"`            // config.DebridProvider.ID
	Kind      string              `json:"kind"`                // config.DebridKinds
	InfoHash  string              `json:"infoHash"`            // lower-case hex v1 info hash
	Magnet    string              `json:"magnet,omitempty"`    // magnet URI used to (re)add the torrent
	TorrentID string              `json:"torrentId,omitempty"` // provider torrent / magnet id
	FileID    string              `json:"fileId,omitempty"`    // provider file id
	Path      string              `json:"path"`                // file path inside the torrent
	Size      int64               `json:"size"`                // file size in bytes
	Link      string              `json:"link,omitempty"`      // provider-side file link (RD/AllDebrid), unrestricted on demand
	URL       string              `json:"url,omitempty"`       // last direct download URL
	Expires   time.Time           `json:"expires,omitempty"`   // when URL should be regenerated
	Target    *core.ReleaseTarget `json:"target,omitempty"`
	Release   string              `json:"release,omitempty"` // release name, for logs
	// Direct HTTP streams (Kind KindHTTP, direct.go): Link is the addon's
	// stream link, Headers the request headers it requires and Origin the
	// owner-configured addon origin. Link and Headers can carry the
	// addon's credentials.
	Headers map[string]string `json:"headers,omitempty"`
	Origin  string            `json:"origin,omitempty"`
}

type Provider interface {
	Kind() string
	// CheckCached reports which hashes are cached; ErrUnsupported when the
	// service has no bulk availability check.
	CheckCached(ctx context.Context, hashes []string) (map[string]bool, error)
	// Find returns the id of a torrent with this hash already on the
	// account ("" when none), so re-adds are avoided; ErrUnsupported when
	// the service keeps no torrent list.
	Find(ctx context.Context, infoHash string) (string, error)
	Acquire(ctx context.Context, req AcquireRequest) (*Acquired, error)
	// Link returns a direct URL for a file; ErrGone when the torrent or
	// file must be re-acquired first.
	Link(ctx context.Context, h Handle) (DirectLink, error)
	Remove(ctx context.Context, torrentID string) error
	Account(ctx context.Context) (Account, error)
}

type ProviderOptions struct {
	HTTPClient   *http.Client
	BaseURL      string
	PollInterval time.Duration // 0 = 500ms
	ReadyPolls   int           // 0 = 6: how long a cached torrent may take to report ready
	Now          func() time.Time
}

type ProviderStats struct {
	ID             string     `json:"id"`
	Name           string     `json:"name"`
	Kind           string     `json:"kind"`
	Enabled        bool       `json:"enabled"`
	Priority       int        `json:"priority"`
	State          string     `json:"state"` // ok, backoff, auth_failed, disabled
	LastError      string     `json:"lastError,omitempty"`
	BackoffUntil   *time.Time `json:"backoffUntil,omitempty"`
	Requests       int64      `json:"requests"`
	Failures       int64      `json:"failures"`
	Cached         int64      `json:"cached"`
	NotCached      int64      `json:"notCached"`
	Blocked        int64      `json:"blocked"` // cached files the provider refused to serve
	LinksRefreshed int64      `json:"linksRefreshed"`
	Reused         int64      `json:"reused"`
	// Slots is how many API calls this node makes to the provider at once:
	// AccountSlots on a standalone server, this node's share of it in a
	// cluster.
	Slots        int        `json:"slots"`
	AccountSlots int        `json:"accountSlots"`
	LastSuccess  *time.Time `json:"lastSuccess,omitempty"`
	Latency      Latency    `json:"latency"`
}

type Service struct {
	// contains filtered or unexported fields
}

type Status struct {
	Enabled    bool            `json:"enabled"`
	CachedOnly bool            `json:"cachedOnly"`
	Providers  []ProviderStats `json:"providers"`
	Engine     *EngineStats    `json:"engine,omitempty"`
}

type TorrentResolver interface {
	ResolveTorrent(ctx context.Context, r core.Release) (core.Release, error)
}