plex

type AccessPolicy = experience.AccessPolicy

type CollectionArtworker interface {
	CollectionArtwork(ctx context.Context, user *core.User, key core.RatingKey, element string, width int) (data []byte, contentType string, ok bool, err error)
}

type Deps struct {
	ArtworkImages       *artworkservice.RemoteCache
	ArtworkPalettes     *artworkservice.PaletteCache
	SessionCoordination *sessions.Coordination
	FavoriteShows       func(context.Context, *core.User) (map[core.RatingKey]bool, error)
	FilterAvailable     func(context.Context, []core.Title) []core.Title
	PrioritizeAvailable func(context.Context, []core.Title) []core.Title
	EpisodeOrder        *episodeorder.Service
	PlexGUID            *plexguid.Service
	PlexMeta            *plexmeta.Service
	Discovery           *DiscoveryFeatures
	LiveTV              *livetv.Service
	AccessPolicy        AccessPolicy
	Catalog             core.Catalog
	Collections         core.Collections
	VibeSearch          core.VibeSearcher
	Recommender         core.Recommender
	State               core.State
	Playlists           core.Playlists
	Auth                core.Auth
	Playback            core.Playback
	Transcoder          core.Transcoder
	// Variants lists distinct release versions for "Play Version" detail
	// pages (optional: without it, detail pages stay single-Media).
	Variants core.VariantResolver
	// DecisionTraces is the latest resolution for a title, copied into a
	// support capture. Nil leaves playback unchanged.
	DecisionTraces core.DecisionTraceSource
	// Downloads remuxes resolved sources to temp MP4s for the Download
	// Queue API; nil disables downloads (allowSync stays "0").
	Downloads        core.DownloadRemuxer
	TrackPreferences TrackPreferences
	Markers          MarkerProvider
	Subtitles        SubtitleSource
	Extras           ExtrasProvider
	Trickplay        core.TrickplayProvider

	// ApplyClientRules adjusts caps for the owner's quality rules. Nil leaves
	// the request caps unchanged. The app wires resolver.ApplyClientRules so
	// this package stays outside the resolver.
	ApplyClientRules func(config.Quality, core.ClientCaps, *core.User) core.ClientCaps
	// Config returns the current settings snapshot.
	Config func() config.Config
	// OwnerSubscription returns the current entitlement snapshot from plex.tv.
	OwnerSubscription func() (active bool, features []string)
	// ImageURL builds TMDB image URLs; defaults to image.tmdb.org.
	ImageURL core.ImageURLFunc
	Logger   *slog.Logger
	Identity Identity
	Hooks    Hooks

	// Sections overrides the default Movies (1) and TV Shows (2) sections.
	Sections []Section
	// HTTPClient fetches artwork for the image proxy; defaults to a client
	// with a 20 s timeout. The app wires the metadata route so this package
	// does not import the egress policy.
	HTTPClient *http.Client
	// DirectHTTP proxies trailer bytes. Nil uses the default transport.
	// The app wires the direct route so this package does not import egress.
	DirectHTTP *http.Client
	// ImageCacheBytes bounds the in-memory artwork cache (default 128 MiB).
	ImageCacheBytes int64
	// DB persists derived artwork data (UltraBlurColors) in plex_* tables.
	// Optional: without it, colours are kept in memory only.
	DB *sql.DB
	// DisableEnrichment turns off the background title-detail and
	// UltraBlurColors work (the spike test library has nothing to fetch).
	DisableEnrichment bool
	// Cluster, when set (clustered nodes only; requires DB), shares play
	// sessions, play queues, terminations and notifications with the other
	// nodes. Nil keeps everything in this process.
	Cluster clusterbus.Node
	// SessionHeartbeat is how often a clustered node refreshes its shared
	// play sessions (default 10s).
	SessionHeartbeat time.Duration
	// Now is the clock (tests).
	Now func() time.Time
	// Dashboard is this node's in-memory Plex Web Dashboard store. Nil is
	// replaced with a process-local store at NewServer. Statistics are not
	// clustered; a client reads the node it connected to.
	Dashboard *stats.Dashboard
	// Resources is this node's host sample ring for /statistics/resources.
	Resources *hoststat.Resources
	// Support records neutral request and playback facts. Nil leaves playback unchanged.
	Support *diagnostics.Recorder
	// TracePlayback logs HLS/transcode requests when ETHER_TRACE_PLAYBACK=1.
	// It does not change responses.
	TracePlayback bool
}

type Directive struct {
	Verb string
	Args map[string]string
}

type DiscoveryFeatures = discovery.Features

type ExtrasProvider interface {
	Enabled() bool
	List(ctx context.Context, parent *core.Title, lang string) ([]extras.Extra, error)
	Lookup(key core.RatingKey) (extras.Extra, bool)
	Resolve(ctx context.Context, e extras.Extra) (extras.Resolved, error)
	PrewarmBytes() int64
}

type Frontend struct {
	NewServer  func() (*Server, error)
	Server     *Server
	WatchState *state.State
	// ExplicitWatchOnly preserves spike mode: only cross-surface scrobbles refresh.
	ExplicitWatchOnly bool
	StatusFunc        func(context.Context) frontend.Status
	ListenersFunc     func() []frontend.ListenerSpec
}

type FrontendArtwork struct {
	Server        *Server
	Variants      func(*core.Title, string) (*tmdb.Images, bool)
	Metadata      func(context.Context, frontend.ArtworkRequest, frontend.Image) frontend.Image
	VirtualSeason func(context.Context, *core.User, core.RatingKey) (*core.Title, error)
	URLImages     interface {
		GetUntrustedURL(context.Context, string) ([]byte, string, error)
	}
	Raster *artwork.SVGRasterizer
}

type Hooks struct {
	// OnClientSeen receives the client identifier after authentication.
	OnClientSeen func(clientID string)
	// OnTimeline is called for every timeline update (prefetch uses it).
	OnTimeline func(user *core.User, key core.RatingKey, offset, duration time.Duration, state string)
	// OnScrobble is called when a user marks an item watched.
	OnScrobble func(user *core.User, key core.RatingKey)
}

type Identity struct {
	MachineIdentifier string
	FriendlyName      string
	Version           string // PMS-style version string
	Platform          string // "MacOSX", "Windows", "Linux"
	PlatformVersion   string
	// MyPlexSubscription reports whether the owner has Plex Pass; Ether
	// reports this honestly from plex.tv.
	MyPlexSubscription bool
	OwnerFeatures      []string
}

type MarkerProvider interface {
	Markers(context.Context, core.RatingKey, core.MediaInfo) ([]markers.Marker, error)
}

type Request struct {
	Token              string
	ClientID           string // X-Plex-Client-Identifier
	Product            string // X-Plex-Product
	Version            string // X-Plex-Version
	Platform           string // X-Plex-Platform
	PlatformVersion    string // X-Plex-Platform-Version
	Device             string // X-Plex-Device
	DeviceName         string // X-Plex-Device-Name
	Model              string // X-Plex-Model
	Vendor             string // X-Plex-Device-Vendor
	Language           string // X-Plex-Language
	Marketplace        string // X-Plex-Marketplace
	Provides           string // X-Plex-Provides
	Features           string // X-Plex-Features
	ProfileExtra       string // X-Plex-Client-Profile-Extra
	ProfileName        string // X-Plex-Client-Profile-Name
	ClientCapabilities string // X-Plex-Client-Capabilities (legacy)
	SessionID          string // X-Plex-Session-Identifier
	PMSAPIVersion      string // X-Plex-Pms-Api-Version

	// Paging (X-Plex-Container-Start/Size); HasPage is false when the client
	// did not ask for a window.
	Start   int
	Size    int
	HasPage bool

	Format   model.Format
	RemoteIP netip.Addr
	Remote   bool // not on a private/loopback network

	User *core.User

	// Capability is set when authentication used a stream grant or other
	// session-scoped credential, not a user token. Only transcode
	// session/segment handlers may serve a capability-scoped request.
	Capability bool
}

type Section struct {
	ID       int
	Type     core.MediaType // movie or show
	Title    string
	UUID     string // stable; derived from the machine identifier when empty
	Language string
}

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

type SessionToucher interface {
	Touch(sessionID string)
}

type SubtitleCatalog interface {
	CachedSidecars(ctx context.Context, t *core.Title, u *core.User, embedded []core.StreamInfo) []core.StreamInfo
}

type SubtitleOffer struct {
	ID              int64  // provider file id, passed back to DownloadSubtitle
	Language        string // ISO 639-1
	Title           string // release or file name
	Provider        string // "OpenSubtitles"
	Score           int
	HearingImpaired bool
	Forced          bool
	PerfectMatch    bool // matched the playing file's hash or release
}

type SubtitleSearch interface {
	SearchSubtitles(ctx context.Context, t *core.Title, u *core.User, lang, release string) ([]SubtitleOffer, error)
	// DownloadSubtitle fetches an offer returned by SearchSubtitles for t
	// and returns its sidecar stream; core.ErrNotFound for unknown offers.
	DownloadSubtitle(ctx context.Context, t *core.Title, u *core.User, id int64) (core.StreamInfo, error)
}

type SubtitleSource interface {
	OpenFormat(string, string) (io.ReadCloser, string, error)
}

type SubtitleTimeline interface {
	OpenFormatAt(id, format string, offset time.Duration) (io.ReadCloser, string, error)
}

type SubtitleUpload interface {
	UploadSubtitle(ctx context.Context, t *core.Title, u *core.User, filename, format, language string, body []byte) (core.StreamInfo, error)
}

type TrackPreferences interface {
	Select(context.Context, int64, core.RatingKey, core.MediaInfo, string) (trackprefs.Selection, error)
	Remember(context.Context, int64, core.RatingKey, string, *core.StreamInfo) error
	GetRules(context.Context, int64) (trackprefs.Rules, error)
}