dao

type AllTokensDto struct {
	model.Token
	UserName  string
	UserMail  string
	UserLrzID string
}

type AuditDao interface {
	// Create a new audit for the database
	Create(*model.Audit) error
	// Find audits
	Find(limit int, offset int, types ...model.AuditType) (audits []model.Audit, err error)
}

type BookmarkDao interface {
	Add(*model.Bookmark) error
	GetByID(uint) (model.Bookmark, error)
	GetByStreamID(uint, uint) ([]model.Bookmark, error)
	Update(*model.Bookmark) error
	Delete(uint) error
}

type CalendarResult struct {
	StreamID        uint
	Created         time.Time
	Start           time.Time
	End             time.Time
	CourseName      string
	LectureHallName string
}

type CameraPresetDao interface {
	GetDefaultCameraPreset(lectureHallID uint) (res model.CameraPreset, err error)
}

type ChatDao interface {
	AddChatPollOptionVote(pollOptionId uint, userId uint) error
	AddChatPoll(poll *model.Poll) error
	AddMessage(chat *model.Chat) error

	GetChatUsers(streamid uint) ([]model.User, error)
	GetReactions(chatID uint) ([]model.ChatReaction, error)
	GetVisibleChats(userID uint, streamID uint) ([]model.Chat, error)
	GetAllChats(userID uint, streamID uint) ([]model.Chat, error)
	GetActivePoll(streamID uint) (model.Poll, error)
	GetPollUserVote(pollId uint, userId uint) (uint, error)
	GetPollOptionVoteCount(pollOptionId uint) (int64, error)
	GetPolls(streamID uint) ([]model.Poll, error)

	ApproveChat(id uint) error
	RetractChat(id uint) error
	DeleteChat(id uint) error
	ResolveChat(id uint) error
	ToggleReaction(userID uint, chatID uint, username string, emoji string) error
	RemoveReactions(chatID uint) error

	CloseActivePoll(streamID uint) error

	GetChatsByUser(userID uint) ([]model.Chat, error)
	GetChat(id uint, userID uint) (*model.Chat, error)
}

type Course struct {
	Name, Slug, TeachingTerm, Visibility string
	ID                                   uint
	Year                                 int
}

type CoursesDao interface {
	CreateCourse(ctx context.Context, course *model.Course, keep bool) error
	AddAdminToCourse(userID uint, courseID uint) error

	GetCurrentOrNextLectureForCourse(ctx context.Context, courseID uint) (model.Stream, error)
	GetAllCourses() ([]model.Course, error)
	GetCourseForLecturerIdByYearAndTerm(c context.Context, year int, term string, userId uint) ([]model.Course, error)
	GetAdministeredCoursesByUserId(ctx context.Context, userid uint, teachingTerm string, year int) (courses []model.Course, err error)
	GetAllCoursesForSemester(ctx context.Context, year int, term string) (courses []model.Course)
	GetPublicCourses(year int, term string) (courses []model.Course, err error)
	GetPublicAndLoggedInCourses(year int, term string) (courses []model.Course, err error)
	GetCourseByToken(token string) (course model.Course, err error)
	GetCourseById(ctx context.Context, id uint) (course model.Course, err error)
	GetInvitedUsersForCourse(course *model.Course) error
	GetCourseBySlugYearAndTerm(ctx context.Context, slug string, term string, year int) (model.Course, error)
	// GetAllCoursesWithTUMIDFromSemester returns all courses with a non-null tum_identifier from a given semester or later
	GetAllCoursesWithTUMIDFromSemester(ctx context.Context, year int, term string) (courses []model.Course, err error)
	GetAvailableSemesters(c context.Context, includeTestSemester bool) []model.Semester
	GetCourseByShortLink(link string) (model.Course, error)
	GetCourseAdmins(courseID uint) ([]model.User, error)
	// ExecAllCourses executes f on all courses from database without batching
	ExecAllCourses(f func([]Course))

	UpdateCourse(ctx context.Context, course model.Course) error
	UpdateCourseMetadata(ctx context.Context, course model.Course)
	UnDeleteCourse(ctx context.Context, course model.Course) error

	RemoveAdminFromCourse(userID uint, courseID uint) error
	DeleteCourse(course model.Course)
}

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

type DaoWrapper struct {
	CameraPresetDao
	ChatDao
	FileDao
	StreamsDao
	CoursesDao
	WorkerDao
	LectureHallsDao
	UsersDao
	UploadKeyDao
	StatisticsDao
	ProgressDao
	ServerNotificationDao
	TokenDao
	NotificationsDao
	IngestServerDao
	VideoSectionDao
	VideoSeekDao
	// AuditDao.Find(...) seems like a nice api, find can be used in other dao as well if type is not embedded
	AuditDao AuditDao
	InfoPageDao
	BookmarkDao BookmarkDao
	SubtitlesDao
	TranscodingFailureDao
	EmailDao
	RunnerDao RunnerDao
}

type EmailDao interface {
	// Get Email by ID
	Get(context.Context, uint) (model.Email, error)

	// Create an new Email for the database
	Create(context.Context, *model.Email) error

	// Delete an Email by id.
	Delete(context.Context, uint) error

	// Save an Email by id.
	Save(context.Context, *model.Email) error

	// GetDue Gets a number of emails that is due for sending.
	GetDue(context.Context, int) ([]model.Email, error)

	// GetFailed Gets all failed sending attempts.
	GetFailed(context.Context) ([]model.Email, error)
}

type FileDao interface {
	NewFile(f *model.File) error
	GetFileById(id string) (f model.File, err error)
	UpdateFile(id string, f *model.File) error
	DeleteFile(id uint) error
	CountVoDFiles() (int64, error)
	SetThumbnail(streamId uint, thumb model.File) error
}

type InfoPageDao interface {
	New(*model.InfoPage) error
	GetAll() ([]model.InfoPage, error)
	GetById(uint) (model.InfoPage, error)
	Update(uint, *model.InfoPage) error
}

type IngestServerDao interface {
	SaveSlot(slot model.StreamName)
	SaveIngestServer(server model.IngestServer)

	GetBestIngestServer() (server model.IngestServer, err error)
	GetTranscodedStreamSlot(ingestServerID uint) (sn model.StreamName, err error)
	GetStreamSlot(ingestServerID uint) (sn model.StreamName, err error)

	RemoveStreamFromSlot(streamID uint) error
}

type LectureHallsDao interface {
	CreateLectureHall(lectureHall model.LectureHall)
	SavePreset(preset model.CameraPreset) error
	SaveLectureHallFullAssoc(lectureHall model.LectureHall)
	SaveLectureHall(lectureHall model.LectureHall) error

	FindPreset(lectureHallID string, presetID string) (model.CameraPreset, error)
	GetAllLectureHalls() []model.LectureHall
	GetLectureHallByPartialName(name string) (model.LectureHall, error)
	GetLectureHallByID(id uint) (model.LectureHall, error)
	GetStreamsForLectureHallIcal(userId uint, lectureHalls []uint, all bool) ([]CalendarResult, error)

	UnsetDefaults(lectureHallID string) error

	DeleteLectureHall(id uint) error
}

type NotificationsDao interface {
	AddNotification(notification *model.Notification) error

	GetNotifications(target ...model.NotificationTarget) ([]model.Notification, error)
	GetAllNotifications() ([]model.Notification, error)

	DeleteNotification(id uint) error
}

type ProgressDao interface {
	SaveProgresses(progresses []model.StreamProgress) error
	GetProgressesForUser(userID uint) ([]model.StreamProgress, error)
	LoadProgress(userID uint, streamIDs []uint) (streamProgress []model.StreamProgress, err error)
	SaveWatchedState(progress *model.StreamProgress) error
}

type RunnerDao interface {
	// Get Runner by ID
	Get(context.Context, string) (model.Runner, error)

	// Create a new Runner for the database
	Create(context.Context, *model.Runner) error

	// Delete a Runner by hostname.
	Delete(context.Context, string) error

	// Update a Runner by hostname.
	Update(context.Context, *model.Runner) error

	// GetAll gets a list of all Runners.
	GetAll(context.Context) ([]model.Runner, error)

	// ReserveRunner returns the runner that currently runs the least jobs and is not draining.
	// It also increments the number of jobs assigned to the runner.
	ReserveRunner(context.Context) (model.Runner, error)
}

type ServerNotificationDao interface {
	CreateServerNotification(notification model.ServerNotification) error

	GetCurrentServerNotifications() ([]model.ServerNotification, error)
	GetAllServerNotifications() ([]model.ServerNotification, error)

	UpdateServerNotification(notification model.ServerNotification, id string) error

	DeleteServerNotification(notificationId string) error
}

type Stat struct {
	X string `json:"x"` // label for stat
	Y int    `json:"y"` // value for stat
}

type StatisticsDao interface {
	AddStat(stat model.Stat) error

	GetCourseNumStudents(courseID uint) (int64, error)
	GetCourseNumVodViews(courseID uint) (int, error)
	GetCourseNumLiveViews(courseID uint) (int, error)
	GetLectureNumVodViews(streamID uint) (int, error)
	GetLectureNumLiveViews(streamID uint) (int, error)
	GetCourseNumVodViewsPerDay(courseID uint) ([]Stat, error)
	GetLectureNumVodViewsPerDay(streamID uint) ([]Stat, error)
	GetCourseStatsWeekdays(courseID uint) ([]Stat, error)
	GetCourseStatsHourly(courseID uint) ([]Stat, error)
	GetLectureStatsWeekdays(courseID uint, streamID uint) ([]Stat, error)
	GetLectureStatsHourly(courseID uint, streamID uint) ([]Stat, error)
	GetLectureStats(courseID uint, lectureID uint) ([]Stat, error)
	GetStudentActivityCourseStats(courseID uint, live bool) ([]Stat, error)
	GetStreamNumLiveViews(streamID uint) (int, error)
}

type StreamWithCourseAndSubtitles struct {
	Name, Description, TeachingTerm, CourseName, Subtitles, Visibility string
	ID, CourseID, Private                                              uint
	Year                                                               int
}

type StreamsDao interface {
	CreateStream(stream *model.Stream) error
	AddVodView(id string) error

	GetDueStreamsForWorkers() []model.Stream
	GetDueStreamsForRunners() ([]model.Stream, error)
	GetDuePremieresForWorkers() []model.Stream
	GetStreamByKey(ctx context.Context, key string) (stream model.Stream, err error)
	GetUnitByID(id string) (model.StreamUnit, error)
	GetStreamByTumOnlineID(ctx context.Context, id uint) (stream model.Stream, err error)
	GetStreamsByIds(ids []uint) ([]model.Stream, error)
	GetStreamByID(ctx context.Context, id string) (stream model.Stream, err error)
	GetWorkersForStream(stream model.Stream) ([]model.Worker, error)
	GetAllStreams() ([]model.Stream, error)
	ExecAllStreamsWithCoursesAndSubtitlesBatched(f func([]StreamWithCourseAndSubtitles))
	GetCurrentLive(ctx context.Context) (currentLive []model.Stream, err error)
	GetCurrentLiveNonHidden(ctx context.Context) (currentLive []model.Stream, err error)
	GetLiveStreamsInLectureHall(lectureHallId uint) ([]model.Stream, error)
	GetStreamsWithWatchState(courseID uint, userID uint) (streams []model.Stream, err error)
	GetSoonStartingStreamInfo(user *model.User, slug string, year int, term string) (string, string, error)
	CreateOrGetTestCourse(user *model.User) (model.Course, error)

	SetLectureHall(streamIDs []uint, lectureHallID uint) error
	UnsetLectureHall(streamIDs []uint) error
	UpdateStream(stream model.Stream) error
	SaveWorkerForStream(stream model.Stream, worker model.Worker) error
	ClearWorkersForStream(stream model.Stream) error
	UpdateSilences(silences []model.Silence, streamID string) error
	DeleteSilences(streamID string) error
	UpdateStreamFullAssoc(vod *model.Stream) error
	SetStreamNotLiveById(streamID uint) error
	SetStreamLiveNowTimestampById(streamID uint, liveNowTimestamp time.Time) error
	SaveEndedState(streamID uint, hasEnded bool) error
	SaveCOMBURL(stream *model.Stream, url string)
	SaveCAMURL(stream *model.Stream, url string)
	SavePRESURL(stream *model.Stream, url string)
	SaveTranscodingProgress(progress model.TranscodingProgress) error
	RemoveTranscodingProgress(streamVersion model.StreamVersion, streamId uint) error
	GetTranscodingProgressByVersion(streamVersion model.StreamVersion, streamId uint) (model.TranscodingProgress, error)
	SaveStream(vod *model.Stream) error
	ToggleVisibility(streamId uint, private bool) error

	DeleteStream(streamID string)
	DeleteUnit(id uint)
	DeleteStreamsWithTumID(ids []uint)
	UpdateLectureSeries(model.Stream) error
	DeleteLectureSeries(string) error
}

type SubtitlesDao interface {
	// Get Subtitles by ID
	Get(context.Context, uint) (model.Subtitles, error)

	// GetByStreamIDandLang returns the subtitles for a given query
	GetByStreamIDandLang(context.Context, uint, string) (model.Subtitles, error)

	// CreateOrUpsert creates or updates subtitles for the database
	CreateOrUpsert(context.Context, *model.Subtitles) error

	// Create saves subtitles
	Create(c context.Context, it *model.Subtitles) error

	// Delete a Subtitles by id.
	Delete(context.Context, uint) error
}

type TokenDao interface {
	AddToken(token model.Token) error

	GetToken(token string) (model.Token, error)
	GetTokenByID(id string) (model.Token, error)
	GetAllTokens(user *model.User) ([]AllTokensDto, error)

	TokenUsed(token model.Token) error

	DeleteToken(id string) error
}

type TranscodingFailureDao interface {
	// All returns all open transcoding failures
	All() ([]model.TranscodingFailure, error)

	// New creates a new transcoding failure
	New(*model.TranscodingFailure) error

	// Delete deletes a transcoding failure
	Delete(id uint) error
}

type UploadKeyDao interface {
	GetUploadKey(key string) (model.UploadKey, error)
	CreateUploadKey(key string, stream uint, videoType model.VideoType) error
	DeleteUploadKey(key model.UploadKey) error
}

type UsersDao interface {
	AreUsersEmpty(ctx context.Context) (isEmpty bool, err error)
	CreateUser(ctx context.Context, user *model.User) (err error)
	DeleteUser(ctx context.Context, uid uint) (err error)
	SearchUser(query string) (users []model.User, err error)
	SearchUserWithRole(query string, role uint64) (users []model.User, err error)
	IsUserAdmin(ctx context.Context, uid uint) (res bool, err error)
	GetUserByEmail(ctx context.Context, email string) (user model.User, err error)
	GetAllAdminsAndLecturers(users *[]model.User) (err error)
	GetUserByID(ctx context.Context, id uint) (user model.User, err error)
	CreateRegisterLink(ctx context.Context, user model.User) (registerLink model.RegisterLink, err error)
	GetUserByResetKey(key string) (model.User, error)
	DeleteResetKey(key string)
	UpdateUser(user model.User) error
	HasPinnedCourse(model.User, uint) (bool, error)
	PinCourse(user model.User, course model.Course, pin bool) error
	UpsertUser(user *model.User) error
	AddUsersToCourseByTUMIDs(matrNr []string, courseID uint) error
	AddUserSetting(userSetting *model.UserSetting) error
}

type VideoSectionDao interface {
	Create([]model.VideoSection) error
	Update(*model.VideoSection) error
	Delete(uint) error
	Get(uint) (model.VideoSection, error)
	GetByStreamId(uint) ([]model.VideoSection, error)
}

type VideoSeekDao interface {
	Add(streamID string, pos float64) error
	Get(streamID string) ([]model.VideoSeekChunk, error)
}

type WorkerDao interface {
	CreateWorker(worker *model.Worker) error
	SaveWorker(worker model.Worker) error

	GetAllWorkers() ([]model.Worker, error)
	GetAliveWorkers() []model.Worker
	GetWorkerByHostname(ctx context.Context, hostname string) (model.Worker, error)
	GetWorkerByID(ctx context.Context, workerID string) (model.Worker, error)

	DeleteWorker(workerID string) error
}