radio

type AnnounceService interface {
	AnnounceSong(context.Context, Status) error
	AnnounceRequest(context.Context, Song) error
	AnnounceUser(context.Context, *User) error
	AnnounceMurder(ctx context.Context, by *User, force bool) error
}

type DJ struct {
	ID    DJID
	Name  string
	Regex string

	Text  string
	Image string

	Visible  bool
	Priority int
	Role     string

	CSS   string
	Color string
	Theme ThemeName
}

type DJID int32

type DatabaseTrack struct {
	TrackID TrackID

	Artist   string
	Title    string
	Album    string
	FilePath string
	Tags     string

	Acceptor   string
	LastEditor string

	Priority        int
	Usable          bool
	NeedReplacement bool

	LastRequested time.Time

	RequestCount int
}

type GuestAction int

type GuestService interface {
	// Create creates a new user based on the nick given and returns the newly created
	// user and passwd if possible, passwd can be empty.
	Create(ctx context.Context, nick string) (user *User, passwd string, err error)
	// Auth authorizes a guest user to the system, allowing them to do certain actions
	Auth(ctx context.Context, nick string) (user *User, err error)
	// Deauth removes a guest user from the authorization list
	Deauth(ctx context.Context, nick string) error
	// Do checks if a guest is allowed to do the GuestAction given and increments any limits if
	// applicable to the action
	Do(ctx context.Context, nick string, can GuestAction) (ok bool, err error)
	// CanDo checks if a guest is allowed to do the GuestAction given
	CanDo(ctx context.Context, nick string, can GuestAction) (ok bool, err error)
}

type LastPlayedKey uint32

type Listener struct {
	ID        ListenerClientID
	UserAgent string
	IP        string
	Start     time.Time
}

type ListenerClientID uint64

type ListenerTrackerService interface {
	// ListClients lists all listeners currently connected
	// to the stream
	ListClients(context.Context) ([]Listener, error)
	// RemoveClient kicks a listener from the stream
	RemoveClient(context.Context, ListenerClientID) error
}

type Listeners = int64

type ManagerService interface {
	UpdateFromStorage(context.Context) error

	CurrentUser(context.Context) (eventstream.Stream[*User], error)
	UpdateUser(context.Context, *User) error
	CurrentSong(context.Context) (eventstream.Stream[*SongUpdate], error)
	UpdateSong(context.Context, *SongUpdate) error
	CurrentThread(context.Context) (eventstream.Stream[Thread], error)
	UpdateThread(context.Context, Thread) error
	CurrentListeners(context.Context) (eventstream.Stream[Listeners], error)
	UpdateListeners(context.Context, Listeners) error

	CurrentStatus(context.Context) (eventstream.Stream[Status], error)
}

type NewsComment struct {
	ID         NewsCommentID
	PostID     NewsPostID
	Body       string
	Identifier string

	// Optional, only filled if an account-holder comments
	UserID    *UserID
	User      *User
	DeletedAt *time.Time
	CreatedAt time.Time
	UpdatedAt *time.Time
}

type NewsCommentID uint32

type NewsList struct {
	Entries []NewsPost
	Total   int
}

type NewsPost struct {
	ID     NewsPostID
	Title  string
	Header string
	Body   string

	User      User
	DeletedAt *time.Time
	CreatedAt time.Time
	UpdatedAt *time.Time
	Private   bool
}

type NewsPostID uint32

type NewsStorage interface {
	// Get returns the news post associated with the id given
	Get(NewsPostID) (*NewsPost, error)
	// Create creates a new news post
	//
	// Required fields to create a post are (title, header, body, user)
	Create(NewsPost) (NewsPostID, error)
	// Update updates the news post entry
	Update(NewsPost) error
	// Delete deletes a news post
	Delete(NewsPostID) error
	// List returns a list of news post starting at offset and returning up to
	// limit amount of posts, chronologically sorted by creation date
	List(limit int64, offset int64) (NewsList, error)
	// ListPublic returns the same thing as List but with deleted and private
	// posts filtered out
	ListPublic(limit int64, offset int64) (NewsList, error)
	// AddComment adds a comment to a news post
	AddComment(NewsComment) (NewsCommentID, error)
	// DeleteComment deletes a comment from a news post
	DeleteComment(NewsCommentID) error
	// Comments returns all comments associated with the news post given
	Comments(NewsPostID) ([]NewsComment, error)
	// CommentsPublic returns all comments that were not deleted
	CommentsPublic(NewsPostID) ([]NewsComment, error)
}

type NewsStorageService interface {
	News(context.Context) NewsStorage
	NewsTx(context.Context, StorageTx) (NewsStorage, StorageTx, error)
}

type PendingSong struct {
	ID SubmissionID
	// Status of the song (accepted/declined/pending)
	Status SubmissionStatus
	// Artist of the song
	Artist string
	// Title of the song
	Title string
	// Album of the song
	Album string
	// Tags of the song
	Tags string
	// FilePath on disk
	FilePath string
	// Comment given by the uploader
	Comment string
	// Filename is the original filename from the uploader
	Filename string
	// UserIdentifier is the unique identifier for the uploader
	UserIdentifier string
	// SubmittedAt is the time of submission
	SubmittedAt time.Time
	// ReviewedAt tells you when the song was reviewed
	ReviewedAt time.Time
	// Duplicate indicates if this might be a duplicate
	Duplicate bool
	// ReplacementID is the TrackID that this upload will replace
	ReplacementID *TrackID
	// Bitrate of the file
	Bitrate uint
	// Length of the song
	Length time.Duration
	// Format of the song
	Format string
	// EncodingMode is the encoding mode used for the file
	EncodingMode string

	// Decline fields
	Reason string

	// Accepted fields
	GoodUpload   bool
	AcceptedSong *Song
}

type PostPendingID int32

type PostPendingSong struct {
	ID             PostPendingID
	AcceptedSong   *TrackID
	Metadata       string
	UserIdentifier string
	ReviewedAt     time.Time
	DeclineReason  *string
	AcceptStatus   SubmissionStatus
}

type ProxyMetadataEvent struct {
	User      User
	MountName string
	Metadata  string
}

type ProxyService interface {
	MetadataStream(context.Context) (eventstream.Stream[ProxyMetadataEvent], error)
	SourceStream(context.Context) (eventstream.Stream[ProxySourceEvent], error)
	StatusStream(context.Context, UserID) (eventstream.Stream[[]ProxySource], error)
	KickSource(context.Context, SourceID) error
	ListSources(context.Context) ([]ProxySource, error)
}

type ProxySource struct {
	User      User
	ID        SourceID
	Start     time.Time
	MountName string
	IP        string
	UserAgent string
	Metadata  string
	Priority  uint32
	IsLive    bool
}

type ProxySourceEvent struct {
	ID        SourceID
	MountName string
	User      User
	Event     ProxySourceEventType
}

type ProxySourceEventType int

type Queue []QueueEntry

type QueueEntry struct {
	// QueueID is a unique identifier for this queue entry
	QueueID QueueID
	// Song that is queued
	Song
	// IsUserRequest should be true if this song was added to the queue
	// by a third-party user
	IsUserRequest bool
	// UserIdentifier should be a way to identify the user that requested the song
	UserIdentifier string
	// ExpectedStartTime is the expected time this song will be played on stream
	ExpectedStartTime time.Time
}

type QueueID struct {
	xid.ID
}

type QueueService interface {
	// AddRequest requests the given song to be added to the queue, the string given
	// is an identifier of the user that requested it
	AddRequest(context.Context, Song, string) error
	// ReserveNext returns the next yet-to-be-reserved entry from the queue
	ReserveNext(context.Context) (*QueueEntry, error)
	// ResetReserved resets the reserved status of all entries returned by ReserveNext
	// but not yet removed by Remove
	ResetReserved(context.Context) error
	// Remove removes the first occurrence of the given entry from the queue
	Remove(context.Context, QueueID) (bool, error)
	// Entries returns all entries in the queue
	Entries(context.Context) (Queue, error)
}

type QueueStorage interface {
	// Store stores the queue with the name given
	Store(name string, queue []QueueEntry) error
	// Load returns the queue associated with the name given
	Load(name string) ([]QueueEntry, error)
}

type QueueStorageService interface {
	Queue(context.Context) QueueStorage
	QueueTx(context.Context, StorageTx) (QueueStorage, StorageTx, error)
}

type Relay struct {
	Name, Status, Stream, Err string
	Online, Disabled, Noredir bool
	Listeners, Max            int
}

type RelayStorage interface {
	Update(r Relay) error
	All() ([]Relay, error)
}

type RelayStorageService interface {
	Relay(context.Context) RelayStorage
	RelayTx(context.Context, StorageTx) (RelayStorage, StorageTx, error)
}

type RequestStorage interface {
	// LastRequest returns the time of when the identifier given last requested
	// a song from the streamer
	LastRequest(identifier string) (time.Time, error)
	// UpdateLastRequest updates the LastRequest time to the current time for the
	// identifier given
	UpdateLastRequest(identifier string) error
}

type RequestStorageService interface {
	Request(context.Context) RequestStorage
	RequestTx(context.Context, StorageTx) (RequestStorage, StorageTx, error)
}

type ScheduleDay uint8

type ScheduleEntry struct {
	ID ScheduleID
	// Weekday is the day this entry is for
	Weekday ScheduleDay
	// Text is the actual body of the entry
	Text string
	// Owner is who "owns" this day for streaming rights
	Owner *User
	// UpdatedAt is when this was updated
	UpdatedAt time.Time
	// UpdatedBy is who updated this
	UpdatedBy User
	// Notification indicates if we should notify users of this entry
	Notification bool
}

type ScheduleID uint32

type ScheduleStorage interface {
	// Latest returns the latest version of the schedule, one entry for
	// each day in order from Monday to Sunday. entry is nil if there is
	// no schedule for that day
	Latest() ([]*ScheduleEntry, error)
	// Update updates the schedule with the entry given
	Update(ScheduleEntry) error
	// History returns the previous versions of ScheduleEntry
	History(day ScheduleDay, limit, offset int64) ([]ScheduleEntry, error)
}

type ScheduleStorageService interface {
	Schedule(context.Context) ScheduleStorage
	ScheduleTx(context.Context, StorageTx) (ScheduleStorage, StorageTx, error)
}

type SearchOptions struct {
	Limit     int64
	Offset    int64
	ExactOnly bool
}

type SearchResult struct {
	Songs     []Song
	TotalHits int
}

type SearchService interface {
	Search(ctx context.Context, query string, opt SearchOptions) (SearchResult, error)
	Update(context.Context, ...Song) error
	Delete(context.Context, ...TrackID) error
}

type Session struct {
	Token  SessionToken
	Expiry time.Time

	Data []byte
}

type SessionStorage interface {
	Delete(SessionToken) error
	Get(SessionToken) (Session, error)
	Save(Session) error
}

type SessionStorageService interface {
	Sessions(context.Context) SessionStorage
	SessionsTx(context.Context, StorageTx) (SessionStorage, StorageTx, error)
}

type SessionToken string

type Song struct {
	ID SongID
	// Hash is a sha1 of the contents of Metadata
	Hash SongHash
	// HashLink is the same as Hash but points to another song that we share some data with
	HashLink SongHash
	// Metadata is simple metadata for this song in the format 'artist - title'
	Metadata string
	// Length is the length of the song
	Length time.Duration
	// LastPlayed is the last time this song played on stream
	LastPlayed time.Time
	// LastPlayedBy is the user that last played this song, can be nil
	LastPlayedBy *User
	// DatabaseTrack is only available if the song is in our streamer database
	*DatabaseTrack

	// SyncTime is the time this Song was returned by the database layer
	SyncTime time.Time
}

type SongHash [sha1.Size]byte

type SongID uint32

type SongInfo struct {
	// Start is the time at which the current song started playing
	Start time.Time
	// End is the expected time the current song stops playing
	End time.Time
}

type SongStorage interface {
	// Create creates a new song with the metadata given
	Create(Song) (*Song, error)
	// FromMetadata returns the song associated with the metadata given
	FromMetadata(metadata string) (*Song, error)
	// FromHash returns the song associated with the SongHash given
	FromHash(SongHash) (*Song, error)

	// LastPlayed returns songs that have recently played, up to amount given after
	// applying the offset
	LastPlayed(key LastPlayedKey, amountPerPage int) ([]Song, error)
	// LastPlayedPagination looks up keys for adjacent pages of key
	LastPlayedPagination(key LastPlayedKey, amountPerPage, pageCount int) (prev, next []LastPlayedKey, err error)
	// LastPlayedCount returns the amount of plays recorded
	LastPlayedCount() (int64, error)
	// PlayedCount returns the amount of times the song has been played on stream,
	// returns 0 if the song doesn't exist
	PlayedCount(Song) (int64, error)
	// AddPlay adds a play to the song. streamer is the dj that played the song.
	// If present, ldiff is the difference in amount of listeners between
	// song-start and song-end.
	AddPlay(song Song, streamer User, ldiff *Listeners) error

	// FavoriteCount returns the amount of users that have added this song to
	// their favorite list, returns 0 if the song doesn't exist
	FavoriteCount(Song) (int64, error)
	// Favorites returns all users that have this song on their favorite list
	Favorites(Song) ([]string, error)
	// FavoritesOf returns all songs that are on a users favorite list
	FavoritesOf(nick string, limit, offset int64) ([]Song, int64, error)
	// FavoritesOfDatabase returns all songs that are on a users favorite list
	// and also have a track database
	FavoritesOfDatabase(nick string) ([]Song, error)
	// AddFavorite adds the given song to nicks favorite list
	AddFavorite(song Song, nick string) (bool, error)
	// RemoveFavorite removes the given song from nicks favorite list
	RemoveFavorite(song Song, nick string) (bool, error)

	// UpdateLength updates the stored length of the song
	UpdateLength(Song, time.Duration) error
	// UpdateHashLink updates the HashLink of the song
	UpdateHashLink(old SongHash, new SongHash) error
}

type SongStorageService interface {
	Song(context.Context) SongStorage
	SongTx(context.Context, StorageTx) (SongStorage, StorageTx, error)
}

type SongUpdate struct {
	Song
	Info SongInfo
}

type SourceID struct {
	xid.ID
}

type Status struct {
	// StreamUser is the user that is currently streaming, will be nil
	// if no one is connected on the master mountpoint (even short drops)
	StreamUser *User
	// User is the user that is currently or was the last to broadcast
	// on the stream
	User User
	// Song is the song that is currently playing on the stream
	Song Song
	// SongInfo is extra information about the song that is currently playing
	SongInfo SongInfo
	// StreamerName is the name given to us by the user that is streaming
	StreamerName string
	// Listeners is the current amount of stream listeners
	Listeners Listeners
	// Thread is an URL to a third-party platform related to the current stream
	Thread string
}

type StatusStorage interface {
	// Store stores the Status given
	Store(Status) error
	// Load returns the previously stored Status
	Load() (*Status, error)
}

type StatusStorageService interface {
	Status(context.Context) StatusStorage
}

type StorageService interface {
	SessionStorageService
	RelayStorageService
	QueueStorageService
	SongStorageService
	TrackStorageService
	RequestStorageService
	UserStorageService
	StatusStorageService
	SubmissionStorageService
	NewsStorageService
	ScheduleStorageService
	// Close closes the storage service and cleans up any resources
	Close() error
}

type StorageTx interface {
	// Commit commits the transaction
	Commit() error
	// Rollback rolls back the transaction
	Rollback() error
}

type StreamerService interface {
	Start(context.Context) error
	Stop(ctx context.Context, who *User, force bool) error

	RequestSong(context.Context, Song, string) error
	// Deprecated: use QueueService
	Queue(context.Context) (Queue, error)
}

type SubmissionID uint32

type SubmissionStats struct {
	// Amount of submissions in the pending queue
	CurrentPending int `db:"current_pending"`
	// Information about accepted songs
	AcceptedTotal        int `db:"accepted_total"`
	AcceptedLastTwoWeeks int `db:"accepted_last_two_weeks"`
	AcceptedYou          int `db:"accepted_you"`
	RecentAccepts        []PostPendingSong

	// Information about declined songs
	DeclinedTotal        int `db:"declined_total"`
	DeclinedLastTwoWeeks int `db:"declined_last_two_weeks"`
	DeclinedYou          int `db:"declined_you"`
	RecentDeclines       []PostPendingSong

	// Information about (You)
	LastSubmissionTime time.Time `db:"last_submission_time"`
}

type SubmissionStatus int

type SubmissionStorage interface {
	// LastSubmissionTime returns the last known time of when the identifier
	// was used to upload a submission
	LastSubmissionTime(identifier string) (time.Time, error)
	// UpdateSubmissionTime updates the last submission time to the current time
	// for the identifier given
	UpdateSubmissionTime(identifier string) error
	// SubmissionStats returns the submission stats for the identifier given.
	SubmissionStats(identifier string) (SubmissionStats, error)

	// All returns all submissions
	All() ([]PendingSong, error)
	// InsertSubmission inserts a new pending song into the database
	InsertSubmission(PendingSong) error
	// GetSubmission returns a pending song by ID
	GetSubmission(SubmissionID) (*PendingSong, error)
	// RemoveSubmission removes a pending song by ID
	RemoveSubmission(SubmissionID) error

	// InsertPostPending inserts post-pending data
	InsertPostPending(PendingSong) error
}

type SubmissionStorageService interface {
	Submissions(context.Context) SubmissionStorage
	SubmissionsTx(context.Context, StorageTx) (SubmissionStorage, StorageTx, error)
}

type Theme struct {
	Name        ThemeName `toml:"-"`
	DisplayName string    `toml:"DisplayName"`
	Description string    `toml:"Description"`
	Author      string    `toml:"Author"`
}

type ThemeName string

type Thread = string

type TrackID uint32

type TrackState int

type TrackStorage interface {
	// Get returns a single track with the TrackID given
	Get(TrackID) (*Song, error)
	// All returns all tracks in storage
	All() ([]Song, error)
	// AllRaw returns all tracks in storage, but without making sure all fields
	// are filled. This returns them as-is straight from storage
	AllRaw() ([]Song, error)
	// Delete removes a track from storage
	Delete(TrackID) error
	// Unusable returns all tracks that are deemed unusable by the streamer
	Unusable() ([]Song, error)
	// NeedReplacement returns the song that need a replacement
	NeedReplacement() ([]Song, error)
	// Insert inserts a new track, errors if ID or TrackID is set
	Insert(song Song) (TrackID, error)
	// Random returns limit amount of usable tracks
	Random(limit int) ([]Song, error)
	// RandomFavorite returns limit amount of tracks that are on the nicks favorite list
	RandomFavoriteOf(nick string, limit int) ([]Song, error)
	// FilterSongsFavoriteOf returns the songs given that are favorite'd by the nick given, it
	// is allowed to mutate the slice given as argument.
	FilterSongsFavoriteOf(nick string, songs []Song) ([]Song, error)

	// UpdateMetadata updates track metadata only (artist/title/album/tags/filepath/needreplacement)
	UpdateMetadata(song Song) error
	// UpdateUsable sets usable to the state given
	UpdateUsable(song Song, state TrackState) error

	// UpdateRequestInfo is called after a track has been requested, this should do any
	// necessary book-keeping related to that
	UpdateRequestInfo(TrackID) error
	// UpdateLastPlayed sets the last time the track was played to the current time
	UpdateLastPlayed(TrackID) error
	// UpdateLastRequested sets the last time the track was requested to the current time
	UpdateLastRequested(TrackID) error

	// BeforeLastRequested returns all tracks that have their LastRequested before the
	// time given
	BeforeLastRequested(before time.Time) ([]Song, error)
	// DecrementRequestCount decrements the RequestCount for all tracks that have
	// their LastRequested before the time given
	DecrementRequestCount(before time.Time) error

	// QueueCandidates returns tracks that are candidates to be queue'd by the
	// default queue implementation
	QueueCandidates() ([]TrackID, error)
}

type TrackStorageService interface {
	Track(context.Context) TrackStorage
	TrackTx(context.Context, StorageTx) (TrackStorage, StorageTx, error)
}

type User struct {
	ID            UserID
	Username      string
	Password      string `json:"-"`
	Email         string
	RememberToken string `json:"-"`
	IP            string

	UpdatedAt *time.Time
	DeletedAt *time.Time
	CreatedAt time.Time

	DJ              DJ
	UserPermissions UserPermissions
}

type UserID uint32

type UserPermission string

type UserPermissions map[UserPermission]struct{}

type UserStorage interface {
	// All returns all users
	All() ([]User, error)
	// Create creates a user
	Create(User) (UserID, error)
	// CreateDJ creates a DJ for the user given
	CreateDJ(User, DJ) (DJID, error)
	// Get returns the user matching the name given
	Get(name string) (*User, error)
	// GetByID returns the user associated with the UserID
	GetByID(UserID) (*User, error)
	// GetByDJID returns the user associated with the DJID
	GetByDJID(DJID) (*User, error)
	// Update updates the given user
	Update(User) (User, error)
	// LookupName matches the name given fuzzily to a user
	LookupName(name string) (*User, error)
	// ByNick returns an user that is associated with the nick given
	ByNick(nick string) (*User, error)
	// Permissions returns all available permissions
	Permissions() ([]UserPermission, error)
	// RecordListeners records a history of listener count
	RecordListeners(Listeners, User) error
}

type UserStorageService interface {
	User(context.Context) UserStorage
	UserTx(context.Context, StorageTx) (UserStorage, StorageTx, error)
}