backup

type AlbumLookupPort interface {
	FindOrCreateAlbum(owner ownermodel.Owner, mediaTime time.Time) (folderName string, created bool, err error)
}

type AlbumReport struct {
	New bool // New is true if the album have been created during the backup
	// contains filtered or unexported fields
}

type AnalysedMedia struct {
	FoundMedia FoundMedia    // FoundMedia is the reference of the file, implementation depends on the VolumeType
	Type       MediaType     // Type is 'photo' or 'video'
	Sha256Hash string        // Sha256Hash sha256 of the file
	Details    *MediaDetails // Details are data found within the file (location, date, ...)
}

type AnalysedMediaObserver interface {
	OnAnalysedMedia(ctx context.Context, media *AnalysedMedia) error
}

type AnalysedMediaObserverFunc func(ctx context.Context, media *AnalysedMedia) error

type Analyser interface {
	Analyse(ctx context.Context, found FoundMedia, analysedMediaObserver AnalysedMediaObserver, rejectsObserver RejectedMediaObserver) error
}

type AnalyserDecorator interface {
	Decorate(analyseFunc Analyser, observers ...AnalyserDecoratorObserver) Analyser
}

type AnalyserDecoratorObserver interface {
	OnDecoratedAnalyser(ctx context.Context, found FoundMedia, cacheHit bool) error
}

type AnalyserInterrupterObserver struct {
	*DefaultInterrupterObserver
}

type AnalyserObserver interface {
	AnalysedMediaObserver
	RejectedMediaObserver
}

type BArchiveAdapter interface {
	// ArchiveMedia uploads the file in the right folder but might change the name to avoid clash with other existing files. Use files name is always returned.
	ArchiveMedia(owner string, media *BackingUpMediaRequest) (string, error)
}

type BackingUpMediaRequest struct {
	AnalysedMedia    *AnalysedMedia
	CatalogReference CatalogReference
}

type BatchScanner struct {
	CataloguerFactory CataloguerFactory
	DetailsReaders    DetailsReaderAdapter
}

type CatalogAdapter interface {
	// IndexMedias add to the catalog following medias
	IndexMedias(owner string, requests []*CatalogMediaRequest) error
}

type CatalogMediaRequest struct {
	BackingUpMediaRequest *BackingUpMediaRequest
	ArchiveFilename       string // ArchiveFilename is a normalised named generated and used in archive.
}

type CatalogReference interface {
	// Exists returns true if the media exists in the catalog
	Exists() bool

	// AlbumCreated returns true if the album was created during the cataloger process
	AlbumCreated() bool

	// AlbumFolderName returns the name of the album where the media would be stored
	AlbumFolderName() string

	// UniqueIdentifier is identifying the media no matter its filename, its id in the catalog (if it's in it or not), its album, ... It's its signature.
	UniqueIdentifier() string

	// MediaId is the id of the media in the catalog and in the archive
	MediaId() string
}

type CatalogReferencerObserver interface {
	OnMediaCatalogued(ctx context.Context, requests []BackingUpMediaRequest) error
}

type CatalogReferencerObserverFunc func(ctx context.Context, requests []BackingUpMediaRequest) error

type Cataloguer interface {
	Reference(ctx context.Context, medias []*AnalysedMedia, observer CatalogReferencerObserver) error
}

type CataloguerFactory interface {
	// NewAlbumCreatorCataloguer returns a Referencer that will create the album if the date is not yet covered.
	NewAlbumCreatorCataloguer(ctx context.Context, owner ownermodel.Owner) (Cataloguer, error)
	// NewDryRunCataloguer returns a Referencer that will not create any album.
	NewDryRunCataloguer(ctx context.Context, owner ownermodel.Owner) (Cataloguer, error)
}

type CataloguerFilter interface {
	// FilterOut returns an error if the media must be filtered out
	FilterOut(ctx context.Context, media AnalysedMedia, reference CatalogReference) error
}

type CataloguerFilterObserver interface {
	OnFilteredOut(ctx context.Context, media AnalysedMedia, reference CatalogReference, cause error) error
}

type CataloguerObserver interface {
	CatalogReferencerObserver
	CataloguerFilterObserver
}

type CataloguerWithFilters struct {
	Delegate                  Cataloguer
	CataloguerFilters         []CataloguerFilter
	CatalogReferencerObserver CatalogReferencerObserver
	CataloguerFilterObserver  CataloguerFilterObserver
}

type ChannelPublisher struct {
	FoundChannel              chan FoundMedia
	AnalysedMediaChannel      chan *AnalysedMedia
	BufferedAnalysedChannel   chan []*AnalysedMedia
	CataloguedChannel         chan *BackingUpMediaRequest
	BufferedCataloguedChannel chan []*BackingUpMediaRequest
	CompletionChannel         chan []error
}

type ClosableFoundMedia interface {
	Close() error
}

type CompletionReport interface {
	Skipped() MediaCounter
	CountPerAlbum() map[string]*AlbumReport
}

type CompositeRunnerObserver struct {
	Observers []interface{}
}

type ConcurrencyParameters struct {
	ConcurrentAnalyserRoutines   int // ConcurrentAnalyserRoutines is the number of concurrent analyser (read files, compute hash, filter out duplicates, ...)
	ConcurrentCataloguerRoutines int // ConcurrentCataloguerRoutines is the number of concurrent cataloguer (find album, create new albums)
	ConcurrentUploaderRoutines   int // ConcurrentUploaderRoutines is the number of concurrent uploader (upload files)
}

type CopyRejectsObserver struct {
	RejectDir string
}

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

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

type DetailsReaderAdapter interface {
	// Supports returns true if the file can be parsed with this reader. False otherwise.
	Supports(media FoundMedia, mediaType MediaType) bool
	// ReadDetails extracts metadata from the content of the file.
	ReadDetails(reader io.Reader, options DetailsReaderOptions) (*MediaDetails, error)
}

type DetailsReaderOptions struct {
	Fast bool // Fast true indicate the parser should focus at extracting the date, nothing else TODO can be retired
}

type ExtraCounts struct {
	Cached   MediaCounter
	Rejected MediaCounter
}

type FoundMedia interface {
	// MediaPath return breakdown of the absolute path of the media.
	MediaPath() MediaPath
	// ReadMedia reads content of the file ; it might not be optimised to call it several times (see VolumeToBackup)
	ReadMedia() (io.ReadCloser, error)
	// Size returns the size of the file
	Size() int

	LastModification() time.Time

	String() string
}

type FullMediaSignature struct {
	Sha256 string
	Size   uint
}

type IErrorCollectorObserver interface {
	RejectedMediaObserver

	Errors() []error
	// contains filtered or unexported methods
}

type ImageOrientation string

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

type InsertMediaPort interface {
	IndexMedias(ctx context.Context, owner ownermodel.Owner, requests []*CatalogMediaRequest) error
}

type Interrupter interface {
	RejectedMediaObserver

	Cancel()
}

type MediaCounter struct {
	Count int // Count is the number of medias
	Size  int // Size is the sum of the size of the medias
}

type MediaDetails struct {
	Width, Height             int
	DateTime                  time.Time
	Orientation               ImageOrientation
	Make                      string
	Model                     string
	GPSLatitude, GPSLongitude float64
	Duration                  int64  // Duration is the length, in milliseconds, of a video
	VideoEncoding             string // VideoEncoding is the codec used to encode the video (ex: 'H264')
}

type MediaPath struct {
	ParentFullPath string // ParentFullPath is the absolute path of the media folder (URL = ParentFullPath + Filename)
	Root           string // Root is the path or URL representing the volume in which the media has been found. (URL = Root + Path + Filename)
	Path           string // Path is the directory path relative to Root: URL = Root + Path + Filename
	Filename       string // Filename does not contain any slash, and contains the extension
	ParentDir      string // ParentDir is the name of the directory: dirname(Root + Path)
}

type MediaType string

type NopeAnalyserDecorator struct {
}

type Options struct {
	RestrictedAlbumFolderName map[string]interface{} // RestrictedAlbumFolderName will restrict the media to only back up medias that are in one of these albums
	Listener                  interface{}            // Listener will receive progress events.
	SkipRejects               bool                   // SkipRejects mode will report any analysis error, or missing timestamp, and continue.
	AnalyserDecorator         AnalyserDecorator      // AnalyserDecorator is an optional decorator to add concept like caching (might be nil)
	DryRun                    bool                   // DryRun mode will not upload anything and do not create albums, still analyse
	ConcurrencyParameters     ConcurrencyParameters
	BatchSize                 int    // BatchSize is the number of items to read from the database at once (used by analyser) ; default to the maximum DynamoDB can handle
	RejectDir                 string // RejectDir is the directory where rejected files will be copied
}

type PostAnalyseFilter interface {
	// AcceptAnalysedMedia returns TRUE if the media should be backed-up.
	AcceptAnalysedMedia(media *AnalysedMedia, folderName string) bool
}

type ProgressObserver struct {
	EventChannel chan *progressEvent
}

type RejectedMediaObserver interface {
	// OnRejectedMedia is called when the media is invalid and cannot be used ; the error is returned only if there is a technical issue.
	OnRejectedMedia(ctx context.Context, found FoundMedia, cause error) error
}

type RunnerUploader interface {
	Upload(buffer []*BackingUpMediaRequest, progressChannel chan *progressEvent) error
}

type RunnerUploaderFunc func(buffer []*BackingUpMediaRequest, progressChannel chan *progressEvent) error

type ScannedFolder struct {
	Name         string
	RelativePath string                  // RelativePath can be used for display purpose
	FolderName   string                  // FolderName is the original folder name (Name with date prefix that have been removed)
	AbsolutePath string                  // AbsolutePath is used to create a new SourceVolume
	Start, End   time.Time               // Start and End are the beginning of the day of the first media, and the beginning of the day following the last media.
	Distribution map[string]MediaCounter // Distribution is the number of media found for each day (format YYYY-MM-DD)
	RejectsCount int                     // RejectsCount is the number of media that have been rejected or filtered out in the folder
}

type SourceVolume interface {
	String() string
	FindMedias() ([]FoundMedia, error)
}

type TimelineAdapter interface {
	FindOrCreateAlbum(mediaTime time.Time) (folderName string, created bool, err error)
	FindAlbum(dateTime time.Time) (folderName string, exists bool, err error)
}

type TrackAnalysed interface {
	OnAnalysed(done, total MediaCounter, others ExtraCounts)
}

type TrackEvents interface {
	OnEvent(event progressEvent)
}

type TrackScanComplete interface {
	OnScanComplete(total MediaCounter)
}

type TrackUploaded interface {
	OnUploaded(done, total MediaCounter)
}

type Tracker struct {
	Done chan struct{} // Done is closed when all events have been processed.
	// contains filtered or unexported fields
}

type Uploader struct {
	Owner           ownermodel.Owner
	InsertMediaPort InsertMediaPort
}