core

type Config struct {
	URL                         string
	DefaultInterval             time.Duration
	PrioritizeSuggestedInterval bool
	HTTPClient                  *http.Client
	RequestHeader               http.Header
	NoRedirectCache             bool
	ManifestTimeout             time.Duration
	ManifestBackoff             backoff.BackOff
	SegmentTimeout              time.Duration
	SegmentBackoff              backoff.BackOff
	SegmentMaxConcurrency       int
	SegmentFilter               SegmentFilter
	StreamType                  StreamType
	TerminateIfVOD              bool
	HLS                         *HLSConfig
	DASH                        *DASHConfig
	// OnDownload will be called when HTTP GET method succeeds.
	// This function must be thread-safe.
	OnDownload  OnDownloadHandler
	OnReport    OnReportHandler
	OnTerminate OnTerminateHandler
}

type DASHConfig struct {
	Inspectors []DASHInspector
}

type DASHInspector interface {
	Inspect(manifest *Manifest, segments SegmentStore) *Report
}

type DASHSegment struct {
	URL             string
	Initialization  bool
	Time            uint64
	Duration        uint64
	Period          *mpd.Period
	AdaptationSet   *mpd.AdaptationSet
	SegmentTemplate *mpd.SegmentTemplate
	Representation  *mpd.Representation
}

type File struct {
	Meta
	Body []byte
}

type FilterResult int

type HLSConfig struct {
	Inspectors []HLSInspector
}

type HLSInspector interface {
	Inspect(playlists *Playlists, segments SegmentStore) *Report
}

type HLSSegment struct {
	URL string
	// VariantParams is reference to related VariantParams object in MasterPlaylist.
	// This property is nullable.
	VariantParams *m3u8.VariantParams
	// Alternative is reference to related Alternative object in MasterPlaylist.
	// This property is nullable.
	Alternative *m3u8.Alternative
}

type Manifest struct {
	URL  string
	Raw  []byte
	Time time.Time
	*mpd.MPD
}

type MasterPlaylist struct {
	URL  string
	Raw  []byte
	Time time.Time
	*m3u8.MasterPlaylist
}

type MediaPlaylist struct {
	URL  string
	Raw  []byte
	Time time.Time
	*m3u8.MediaPlaylist
	VariantParams *m3u8.VariantParams
	Alternative   *m3u8.Alternative
}

type Meta struct {
	URL              string        `json:"url"`
	Via              string        `json:"via"`
	RequestHeader    http.Header   `json:"requestHeader"`
	ResponseHeader   http.Header   `json:"responseHeader"`
	Status           string        `json:"status"`     // e.g. "200 OK"
	StatusCode       int           `json:"statusCode"` // e.g. 200
	Proto            string        `json:"proto"`      // e.g. "HTTP/1.0"
	ProtoMajor       int           `json:"protoMajor"` // e.g. 1
	ProtoMinor       int           `json:"protoMinor"` // e.g. 0
	ContentLength    int64         `json:"contentLength"`
	TransferEncoding []string      `json:"transferEncoding"`
	Uncompressed     bool          `json:"uncompressed"`
	RequestTimestamp time.Time     `json:"requestTimestamp"`
	DownloadTime     time.Duration `json:"downloadTime"`
}

type Monitor interface {
	Terminate()
}

type OnDownloadHandler func(file *File)

type OnReportHandler func(reports Reports)

type OnTerminateHandler func()

type Playlists struct {
	MasterPlaylist *MasterPlaylist
	MediaPlaylists map[string]*MediaPlaylist
}

type Report struct {
	Name     string   `json:"name"`
	Severity Severity `json:"severity"`
	Message  string   `json:"message"`
	Values   Values   `json:"values"`
}

type Reports []*Report

type SegmentFilter interface {
	CheckHLS(segment *HLSSegment) FilterResult
	CheckDASH(segment *DASHSegment) FilterResult
}

type SegmentStore interface {
	Exists(url string) bool
	Load(url string) ([]byte, bool)
}

type Severity int

type StreamType int

type TemplateParams struct {
	RepresentationID string
	Number           int64
	Bandwidth        int64
	Time             uint64
}

type Values map[string]interface{}