controller

type AudioTrack struct {
	Index    int `json:"index"`    // "StreamOrder" (MI), "index" (FF)
	Channels int `json:"channels"` // "Channels" (MI), "channels" (FF)
}

type CompletedJob struct {
	UUID    UUID    `json:"uuid"`
	Failed  bool    `json:"failed"`
	History History `json:"history"`
	InFile  string  `json:"-"`
}

type DispatchedJob struct {
	UUID        UUID      `json:"uuid"`
	Runner      string    `json:"runner"`
	Job         Job       `json:"job"`
	Status      JobStatus `json:"status"`
	LastUpdated time.Time `json:"last_updated"`
}

type File struct {
	Path     string
	ModTime  time.Time
	Metadata FileMetadata
}

type FileCacheDataStorer interface {
	Modtime(path string) (time.Time, error)
	Metadata(path string) (FileMetadata, error)

	SaveModtime(path string, t time.Time) error
	SaveMetadata(path string, f FileMetadata) error
}

type FileMetadata struct {
	General        General         `json:"general"`
	VideoTracks    []VideoTrack    `json:"video_tracks"`
	AudioTracks    []AudioTrack    `json:"audio_tracks"`
	SubtitleTracks []SubtitleTrack `json:"subtitle_tracks"`
}

type General struct {
	// It looks like any non-string field will have to be parsed
	Duration float32 `json:"duration"`
}

type HTTPServer interface {
	// Start starts the HTTPServer. If Start is called again, it is a no-op.
	Start(*context.Context, *sync.WaitGroup)

	Handle(pattern string, handler http.Handler)
	HandleFunc(pattern string, handlerFunc func(http.ResponseWriter, *http.Request))
}

type HealthChecker interface {
	// Run loops through the provided slice of dispatched jobs and checks if any have
	// surpassed the allowed time between updates.
	Run() (uuidsToNull []UUID)

	Start(ctx *context.Context)
}

type HealthCheckerDataStorer interface {
	DispatchedJobs() []DispatchedJob
	DeleteJob(uuid UUID) error
}

type History struct {
	Filename          string    `json:"file"`
	DateTimeCompleted time.Time `json:"datetime_completed"`
	Warnings          []string  `json:"warnings"`
	Errors            []string  `json:"errors"`
}

type Job struct {
	UUID     UUID         `json:"uuid"`
	Path     string       `json:"path"`
	Command  []string     `json:"command"`
	Metadata FileMetadata `json:"metadata"`
}

type JobStatus struct {
	Stage                       string `json:"stage"`
	Percentage                  string `json:"percentage"`
	JobElapsedTime              string `json:"job_elapsed_time"`
	FPS                         string `json:"fps"`
	StageElapsedTime            string `json:"stage_elapsed_time"`
	StageEstimatedTimeRemaining string `json:"stage_estimated_time_remaining"`
}

type Library struct {
	ID                     int           `json:"id"`
	Folder                 string        `json:"folder"`
	Priority               int           `json:"priority"`
	FsCheckInterval        time.Duration `json:"fs_check_interval"`
	Queue                  LibraryQueue  `json:"queue"`
	PathMasks              []string      `json:"path_masks"`
	CommandDeciderSettings string        `json:"command_decider_settings"` // We are using a string for the CommandDecider settings because it is easier for the frontend to convert back and forth from when setting and reading values.
}

type LibraryManager interface {
	// ImportCompletedJobs imports the provided jobs into the system.
	ImportCompletedJobs([]CompletedJob)

	// LibrarySettings returns the current settings of all libraries (including the queues).
	LibrarySettings() ([]Library, error)

	// PopNewJob returns a job that may be dispatched as well as deletes it from any
	// data stores.
	PopNewJob() (Job, error)

	// UpdateLibrarySettings loops through the provided map of new settings and applies
	// them to the appropriate libraries.
	UpdateLibrarySettings(map[int]Library)

	Start(ctx *context.Context, wg *sync.WaitGroup)
}

type LibraryManagerDataStorer interface {
	Libraries() ([]Library, error)
	Library(id int) (Library, error)
	SaveLibrary(Library) error

	IsPathDispatched(path string) (bool, error)
	PopDispatchedJob(uuid UUID) (DispatchedJob, error)

	PushHistory(History) error
}

type LibraryQueue struct {
	Items []Job
}

type Logger interface {
	Trace(s string, i ...interface{})
	Debug(s string, i ...interface{})
	Info(s string, i ...interface{})
	Warn(s string, i ...interface{})
	Error(s string, i ...interface{})
	Critical(s string, i ...interface{})
}

type RunnerCommunicator interface {
	// CompletedJobs returns a slice of jobs that are ready to be imported back into the
	// system.
	CompletedJobs() []CompletedJob

	// NewJob takes the provided job and sends it to a waiting Runner.
	NewJob(Job)

	// NeedNewJob returns a boolean indicating whether or not a new job is required.
	NeedNewJob() bool

	// NullifyUUIDs takes the provided slice of UUIDs and marks them
	// so that if a Runner sends a request with a nullified UUID, it gets notified
	// that it is considered unresponsive and should acquire a new job.
	NullifyUUIDs([]UUID)

	// WaitingRunners returns the names of all the Runners which are waiting for a job.
	WaitingRunners() (runnerNames []string)

	Start(ctx *context.Context, wg *sync.WaitGroup)
}

type RunnerCommunicatorDataStorer interface {
	DispatchedJob(uuid UUID) (DispatchedJob, error)
	SaveDispatchedJob(DispatchedJob) error
}

type SettingsStorer interface {
	Load() error
	Save() error
	Close() error

	HealthCheckInterval() uint64
	SetHealthCheckInterval(uint64)

	HealthCheckTimeout() uint64
	SetHealthCheckTimeout(uint64)

	LogVerbosity() string
	SetLogVerbosity(string)
}

type SubtitleTrack struct {
	Index    int    `json:"index"`    // "StreamOrder" (MI), "index" (FF)
	Language string `json:"language"` // "Language" (MI), "tags.language"
}

type UUID string

type UserInterfacer interface {
	// NewLibrarySettings returns a map of all updated library settings as set by the user.
	NewLibrarySettings() map[int]Library

	// SetLibrarySettings takes the provided slice of LibrarySettings and stores it
	// for an incoming request.
	SetLibrarySettings([]Library)

	// SetWaitingRunners stores an updated value that should be sent if a request to view
	// the waiting Runner is received.
	SetWaitingRunners(runnerNames []string)

	Start(ctx *context.Context, wg *sync.WaitGroup)
}

type UserInterfacerDataStorer interface {
	DispatchedJobs() ([]DispatchedJob, error)

	HistoryEntries() ([]History, error)

	DeleteLibrary(id int) error
}

type VideoTrack struct {
	Index int    `json:"index"` // "StreamOrder" (MI), "index" (FF)
	Codec string `json:"codec"` // Either "AVC", "HEVC", etc.
	// Bitrate        int    `json:"bitrate"`         // "BitRate" (MI), "bit_rate" (FF) // Not implemented for now because I want bitrate per stream, not overall file.
	Width          int    `json:"width"`           // "Width" (MI), "width" (FF)
	Height         int    `json:"height"`          // "Height" (MI), "height" (FF)
	ColorPrimaries string `json:"color_primaries"` // "colour_primaries" (MI), "color_primaries" (FF) Will be different based on which MetadataReader is being used (FF gives "bt2020" while MI gives "BT.2020")
}