plextv

type APIError struct {
	Method     string
	Path       string
	Status     int
	Code       int // plex.tv error code, e.g. 1001
	Message    string
	RetryAfter time.Duration
}

type Account struct {
	ID           int64        `json:"id"`
	UUID         string       `json:"uuid"`
	Username     string       `json:"username"`
	Title        string       `json:"title"`
	FriendlyName string       `json:"friendlyName"`
	Email        string       `json:"email"`
	Thumb        string       `json:"thumb"`
	AuthToken    string       `json:"authToken"`
	Home         bool         `json:"home"`
	HomeAdmin    bool         `json:"homeAdmin"`
	Restricted   bool         `json:"restricted"`
	Subscription Subscription `json:"subscription"`
}

type CertBundle struct {
	CertPEM []byte // leaf first, then any chain
	KeyPEM  []byte // PKCS#8
	Leaf    *x509.Certificate
	Hash    string // plex.direct hash ("" for self-signed without one)
	Subject string // e.g. "*.<hash>.plex.direct"
}

type CertInfo struct {
	Present     bool          `json:"present"`
	SelfSigned  bool          `json:"selfSigned"`
	Custom      bool          `json:"custom"` // owner-supplied files, never replaced
	Hash        string        `json:"hash,omitempty"`
	Subject     string        `json:"subject,omitempty"`
	DNSNames    []string      `json:"dnsNames,omitempty"`
	NotBefore   time.Time     `json:"notBefore,omitempty"`
	NotAfter    time.Time     `json:"notAfter,omitempty"`
	Fingerprint string        `json:"fingerprint,omitempty"`
	CertFile    string        `json:"certFile,omitempty"`
	KeyFile     string        `json:"keyFile,omitempty"`
	LastAttempt time.Time     `json:"lastAttempt,omitempty"` // last plex.tv request
	NextAttempt time.Time     `json:"nextAttempt,omitempty"`
	RetryAfter  time.Duration `json:"retryAfter,omitempty"`
	LastError   string        `json:"lastError,omitempty"`
}

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

type CertManagerOptions struct {
	// Dir holds plexdirect.crt, plexdirect.key and cert-state.json.
	Dir string
	// Client must carry the server identity.
	Client *Client
	// CustomCertFile/CustomKeyFile, when set to files outside Dir, are an
	// owner-supplied certificate: loaded and reported, never replaced.
	CustomCertFile string
	CustomKeyFile  string
	// RenewBefore triggers renewal this long before expiry (default: a third
	// of the certificate's lifetime, at least 7 days).
	RenewBefore time.Duration
	// RetryAfter is the minimum gap between plex.tv certificate requests
	// after a failure (default 24h). plex.tv rate-limits CSR uploads per
	// device; PMS servers that retried daily ended up locked out for days.
	RetryAfter time.Duration
	// ClientErrorRetryAfter controls retries after non-429 4xx responses,
	// which usually indicate a malformed request. Default: 5 minutes.
	ClientErrorRetryAfter time.Duration
	// SelfSignedValidity for the fallback certificate (default 1 year).
	SelfSignedValidity time.Duration
	// Request overrides the download timing (tests).
	Request CertRequest
	// Shared, on a cluster node, holds the certificate for every node
	// (see certshared.go). Nil: a standalone server keeps it in Dir only.
	Shared SharedCertStore
	Logger *slog.Logger
	Now    func() time.Time
}

type CertRequest struct {
	// Key is the private key to certify; a fresh RSA-2048 key when nil
	// (RSA for compatibility with older TV clients).
	Key crypto.Signer
	// Reason is "missing" (no certificate yet) or "expiring", as PMS sends.
	Reason string
	// InvalidIn is seconds until the current certificate stops being valid
	// (negative when already expired; 0 when missing), as PMS sends.
	InvalidIn int
	// PollInterval between download attempts (default 3s) and Timeout for
	// the whole download phase (default 90s, PMS's window).
	PollInterval time.Duration
	Timeout      time.Duration
}

type ClaimResult struct {
	ServerToken string
	Owner       Account
	Method      string
}

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

type ConfigStore interface {
	Get() config.Config
	Update(fn func(*config.Config) error) error
}

type EventBus interface {
	Publish(ctx context.Context, topic string, payload []byte) error
	Subscribe(topic string, fn func([]byte)) (unsubscribe func())
}

type Friend struct {
	PlexID     int64    `json:"plexId"`
	UUID       string   `json:"uuid,omitempty"`
	Username   string   `json:"username"`
	Title      string   `json:"title"`
	Email      string   `json:"email,omitempty"`
	Thumb      string   `json:"thumb,omitempty"`
	Token      string   `json:"-"`
	Owned      bool     `json:"owned"` // the owner's own access token
	Home       bool     `json:"home"`
	Restricted bool     `json:"restricted"` // managed user
	Pending    bool     `json:"pending"`    // invite not accepted yet
	AllLibs    bool     `json:"allLibraries"`
	Sections   []string `json:"sections,omitempty"` // shared section keys
}

type Identity struct {
	Product          string
	Version          string
	ClientIdentifier string
	DeviceName       string
	Device           string
	Platform         string
	PlatformVersion  string
	// Provides is "server" for the server identity, empty for the wizard.
	Provides string
}

type Options struct {
	VersionSource func() string
	BaseURL       string // DefaultBaseURL when empty
	AuthAppURL    string // DefaultAuthAppURL when empty
	HTTPClient    *http.Client
	Identity      Identity
	Logger        *slog.Logger
	// RetryBackoff is the initial delay between retries of idempotent
	// requests (default 500ms).
	RetryBackoff time.Duration
}

type PIN struct {
	ID               int64  `json:"id"`
	Code             string `json:"code"`
	ClientIdentifier string `json:"clientIdentifier"`
	Trusted          bool   `json:"trusted"`
	ExpiresIn        int    `json:"expiresIn"`
	ExpiresAt        time.Time
	// AuthToken is set once the user approved the PIN.
	AuthToken string `json:"authToken"`
}

type PortMapper interface {
	Ensure(ctx context.Context, internal, external int) (remote.MappingStatus, error)
	Status() remote.MappingStatus
	Close(ctx context.Context)
}

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

type PresenceOptions struct {
	Client *Client
	// Credentials returns the owner's plex.tv id, this server's machine
	// identifier and server token; ok=false while unclaimed.
	Credentials func() (ownerID int64, machineID, token string, ok bool)
	OnMessage   func(PubsubMessage)
	// StreamClient performs the SSE request; defaults to one verifying TLS
	// against PubsubTLSName.
	StreamClient *http.Client
	// StreamURL builds the stream URL for a host (tests use http).
	StreamURL              func(host string, ownerID int64, machineID, token string) string
	MinBackoff, MaxBackoff time.Duration
	// IdleTimeout reconnects when the stream delivers no bytes for this long
	// (default 5m). Pubsub sends ": -1" keep-alive comments, so silence
	// means a half-open connection (NAT timeout, sleep/wake) that would
	// otherwise block the reader forever and leave the server offline.
	IdleTimeout time.Duration
}

type PresenceStatus struct {
	Connected   bool      `json:"connected"`
	Host        string    `json:"host,omitempty"`
	Since       time.Time `json:"since,omitempty"`
	LastError   string    `json:"lastError,omitempty"`
	LastMessage string    `json:"lastMessage,omitempty"`
}

type PublishFlags struct {
	HTTPSEnabled           bool
	HTTPSRequired          bool
	DNSRebindingProtection bool
	NATLoopbackSupported   bool
}

type PubsubMessage struct {
	Command         string `xml:"command,attr"`
	AsyncIdentifier string `xml:"asyncIdentifier,attr"`
	Connectivity    string `xml:"connectivity,attr"`
	Address         string `xml:"address,attr"`
	Port            string `xml:"port,attr"`
	Raw             string `xml:"-"`
}

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

type RegistrarOptions struct {
	Config ConfigStore
	// Client carries the server identity; built from Config when nil.
	Client  *Client
	BaseURL string // for the default client (tests)
	Version string // PMS version reported to plex.tv
	Users   UserSync
	WAN     WANDetector
	LAN     func() ([]net.IP, error)
	Mapper  PortMapper // nil creates a remote.PortMapper
	Reach   *remote.ReachabilityChecker
	Certs   *CertManager // nil disables certificate management

	// Intervals (defaults in parentheses).
	Tick                 time.Duration // loop granularity (15s)
	AddressInterval      time.Duration // LAN/WAN re-check (30s)
	PublishInterval      time.Duration // unconditional re-publish (1h)
	FriendSyncInterval   time.Duration // access token sync (1m, observed)
	MappingInterval      time.Duration // UPnP/NAT-PMP renew check (5m)
	CertInterval         time.Duration // certificate expiry check (1w, observed when not near expiry)
	ReachabilityInterval time.Duration // remote self-test (1h, observed)

	// PeerURIs, when set (clustered servers), returns the other live
	// nodes' connection URIs in publication order. PublishNow appends them,
	// de-duplicated, after this node's own URIs so plex.tv lists the union.
	// It is called on every publish and must not block on the network.
	PeerURIs func() []string

	// NodeMapping moves port mapping out of the publishing loop: the owner
	// runs RunPortMapping on every node (each cluster node is reached
	// through its own port forward, plex.publicPort being node-local), and
	// Stop leaves the mapping in place. Off, the loop maps the port and
	// Stop removes the mapping (a standalone server).
	NodeMapping bool

	// PublishPlexDirect also publishes the https plex.direct URIs. Off by
	// default: PMS publishes plain http URIs and plex.tv synthesises the
	// plex.direct https variants for clients asking with includeHttps=1.
	PublishPlexDirect bool

	Logger *slog.Logger
	Now    func() time.Time
}

type Resource struct {
	Name                   string               `json:"name"`
	Product                string               `json:"product"`
	ProductVersion         string               `json:"productVersion"`
	Platform               string               `json:"platform"`
	PlatformVersion        string               `json:"platformVersion"`
	Device                 string               `json:"device"`
	ClientIdentifier       string               `json:"clientIdentifier"`
	CreatedAt              flexTime             `json:"createdAt"`
	LastSeenAt             flexTime             `json:"lastSeenAt"`
	Provides               string               `json:"provides"`
	OwnerID                *int64               `json:"ownerId"`
	SourceTitle            string               `json:"sourceTitle"`
	PublicAddress          string               `json:"publicAddress"`
	AccessToken            string               `json:"accessToken"`
	Owned                  bool                 `json:"owned"`
	Home                   bool                 `json:"home"`
	Synced                 bool                 `json:"synced"`
	Relay                  bool                 `json:"relay"`
	Presence               bool                 `json:"presence"`
	HTTPSRequired          bool                 `json:"httpsRequired"`
	PublicAddressMatches   bool                 `json:"publicAddressMatches"`
	DNSRebindingProtection bool                 `json:"dnsRebindingProtection"`
	NatLoopbackSupported   bool                 `json:"natLoopbackSupported"`
	Connections            []ResourceConnection `json:"connections"`
}

type ResourceConnection struct {
	Protocol string `json:"protocol"`
	Address  string `json:"address"`
	Port     int    `json:"port"`
	URI      string `json:"uri"`
	Local    bool   `json:"local"`
	Relay    bool   `json:"relay"`
	IPv6     bool   `json:"IPv6"`
}

type ServerRegistration struct {
	Name           string
	Address        string // public IP; empty lets plex.tv use the request's source address
	Port           int    // public (mapped) port; 0 when not published
	PrivateAddress string // primary LAN address (not part of the PMS body)
	PrivatePort    int    // listener port (not part of the PMS body)
	Version        string
	LocalAddresses []string // LAN IPs
	// MappingState mirrors PMS's states: "mapped", "unmapped", "unknown".
	// PMS does not send it in servers.xml; it is kept for callers.
	MappingState string
	// Now stamps the "date" attribute; zero means time.Now().
	Now time.Time
}

type Service struct {
	PlexID     int64
	Identifier string
	Endpoint   string
	Status     string
}

type SharedCertStore interface {
	Get(ctx context.Context, name string) ([]byte, int64, error)
	Put(ctx context.Context, name string, data []byte) (int64, error)
	Version(ctx context.Context, name string) (int64, error)
}

type SharedUser struct {
	PlexID        int64
	UUID          string
	Username      string
	Title         string
	Email         string
	Thumb         string
	Home          bool
	Restricted    bool
	PlexPass      bool
	PlexPassKnown bool
	// Servers are the machine identifiers shared with the user.
	Servers []string
}

type Status struct {
	Claimed           bool   `json:"claimed"`
	OwnerUsername     string `json:"ownerUsername,omitempty"`
	MachineIdentifier string `json:"machineIdentifier"`

	LANAddresses []string            `json:"lanAddresses"`
	PublicIP     string              `json:"publicIp,omitempty"`
	PublicIPErr  string              `json:"publicIpError,omitempty"`
	Connections  []remote.Connection `json:"connections"`

	PublishedURIs    []string  `json:"publishedUris"`
	LastPublish      time.Time `json:"lastPublish,omitempty"`
	LastPublishError string    `json:"lastPublishError,omitempty"`
	RegisterError    string    `json:"registerError,omitempty"` // servers.xml (non-fatal)

	// Listed reports whether plex.tv's resources list contains this server;
	// ResourceConnections is what clients will be offered.
	Listed              bool                 `json:"listed"`
	ResourceConnections []ResourceConnection `json:"resourceConnections,omitempty"`
	PublicAddress       string               `json:"publicAddress,omitempty"` // as plex.tv sees us
	PlexPass            bool                 `json:"plexPass"`                // owner subscription active

	RemoteAccess bool                 `json:"remoteAccess"`
	Reachability *remote.Reachability `json:"reachability,omitempty"`
	UPnP         remote.MappingStatus `json:"upnp"`

	Cert      CertInfo `json:"cert"`
	CertError string   `json:"certError,omitempty"`

	// Presence is the plex.tv pubsub stream that marks the server online.
	Presence PresenceStatus `json:"presence"`
	// PlexReachable is plex.tv's last notifyConnectivity verdict for our
	// published address (nil until one arrives).
	PlexReachable   *bool     `json:"plexReachable,omitempty"`
	Friends         int       `json:"friends"`
	LastFriendSync  time.Time `json:"lastFriendSync,omitempty"`
	FriendSyncError string    `json:"friendSyncError,omitempty"`
}

type Subscription struct {
	Active   bool     `json:"active"`
	Status   string   `json:"status"`
	Plan     string   `json:"plan"`
	Features []string `json:"features"`
}

type UserSync interface {
	SetOwner(ctx context.Context, owner Account, serverToken string) error
	SyncFriends(ctx context.Context, friends []Friend) error
}

type WANDetector interface {
	Detect(ctx context.Context) (net.IP, error)
}