dirscan

type Config struct {
	// SchedulerInterval is how often to check for scheduled scans.
	SchedulerInterval time.Duration

	// MaxJitter is the maximum random delay before starting a scheduled scan.
	MaxJitter time.Duration

	// MaxConcurrentRuns limits how many scans can run across all directories.
	// This helps avoid stampeding indexers if multiple directories are due at once.
	MaxConcurrentRuns int
}

type InjectRequest struct {
	// InstanceID is the target qBittorrent instance.
	InstanceID int

	// TorrentBytes contains the .torrent file contents.
	TorrentBytes []byte

	// ParsedTorrent is the parsed torrent metadata for TorrentBytes.
	ParsedTorrent *ParsedTorrent

	// Searchee that was matched.
	Searchee *Searchee

	// MatchResult is the file-level match for this searchee and ParsedTorrent.
	MatchResult *MatchResult

	// SearchResult that matched the searchee.
	SearchResult *jackett.SearchResult

	// SavePath is the path where qBittorrent should save the torrent.
	// This should point to the parent directory of the searchee.
	SavePath string

	// QbitPathPrefix is an optional path prefix to apply for container path mapping.
	// If set, replaces the searchee's path prefix for qBittorrent injection.
	QbitPathPrefix string

	// Category to assign to the torrent.
	Category string

	// Tags to assign to the torrent.
	Tags []string

	// StartPaused adds the torrent in paused state.
	StartPaused bool
}

type InjectResult struct {
	// Success is true if the torrent was added successfully.
	Success bool

	// TorrentHash is the hash of the added torrent.
	TorrentHash string

	// Mode describes how the torrent was added: hardlink, reflink, or regular.
	Mode string

	// SavePath is the save path used when adding the torrent.
	SavePath string

	// Error message if injection failed.
	ErrorMessage string
}

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

type InstanceProvider interface {
	Get(ctx context.Context, id int) (*models.Instance, error)
}

type JackettDownloader interface {
	DownloadTorrent(ctx context.Context, req jackett.TorrentDownloadRequest) ([]byte, error)
}

type JackettSearcher interface {
	SearchWithScope(ctx context.Context, req *jackett.TorznabSearchRequest, scope string) error
}

type MatchMode string

type MatchResult struct {
	// IsMatch is true if the match criteria were met
	IsMatch bool

	// MatchedFiles contains the matched file pairs
	MatchedFiles []MatchedFilePair

	// UnmatchedSearcheeFiles contains searchee files that weren't matched
	UnmatchedSearcheeFiles []*ScannedFile

	// UnmatchedTorrentFiles contains torrent files that weren't matched
	UnmatchedTorrentFiles []TorrentFile

	// MatchRatio is the ratio of matched files (0.0-1.0)
	MatchRatio float64

	// SizeMatchRatio is the ratio of matched size (0.0-1.0)
	SizeMatchRatio float64

	// IsPerfectMatch is true if all files matched
	IsPerfectMatch bool

	// IsPartialMatch is true if some but not all files matched
	IsPartialMatch bool
}

type MatchedFilePair struct {
	SearcheeFile *ScannedFile
	TorrentFile  TorrentFile
}

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

type ParsedTorrent struct {
	Name        string
	InfoHash    string
	Files       []TorrentFile
	TotalSize   int64
	PieceLength int64
	PieceCount  int
}

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

type ScanResult struct {
	Searchees    []*Searchee // Searchees found
	TotalFiles   int         // Total media files found
	TotalSize    int64       // Total size in bytes
	SkippedFiles int         // Files skipped (already seeding, etc.)
}

type ScannedFile struct {
	Path      string          // Absolute path to the file
	RelPath   string          // Relative path from searchee root
	Size      int64           // File size in bytes
	ModTime   time.Time       // Modification time
	FileID    hardlink.FileID // Platform-specific file identifier
	LinkCount uint64          // Hardlink count
	HasLinks  bool            // True if file has multiple hardlinks (count > 1)
}

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

type SearchRequest struct {
	// Searchee to search for
	Searchee *Searchee

	// Metadata parsed from the searchee name (optional, will be parsed if nil)
	Metadata *SearcheeMetadata

	// IndexerIDs to search (empty = all enabled indexers)
	IndexerIDs []int

	// Categories to search (optional, but recommended for better results).
	Categories []int

	// Limit results per indexer
	Limit int

	// OnAllComplete is called when all search jobs complete with the final results
	OnAllComplete func(response *jackett.SearchResponse, err error)
}

type SearchResult struct {
	*jackett.SearchResult

	// IndexerID that returned this result
	IndexerID int

	// Searchee this result is for
	Searchee *Searchee

	// MatchScore indicates match quality (higher is better)
	MatchScore float64
}

type Searchee struct {
	Name   string         // Release name (folder or file base name)
	Path   string         // Absolute path to the searchee root
	Files  []*ScannedFile // Files in this searchee
	IsDisc bool           // True if this is a disc-layout folder
}

type SearcheeMetadata struct {
	// Original name before any processing
	OriginalName string

	// CleanedName has TRaSH IDs removed (suitable for rls parsing)
	CleanedName string

	// TRaSH IDs extracted from the name
	TRaSH TRaSHMetadata

	// Release metadata from rls parsing
	Release *rls.Release

	// Derived search fields
	Title   string // Cleaned title for search queries
	Year    int    // Year if detected
	Season  *int   // Season number for TV
	Episode *int   // Episode number for TV

	// Content type hints
	IsTV    bool
	IsMovie bool
	IsMusic bool
}

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

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

type TRaSHMetadata struct {
	TMDbID  int    // From {tmdb-345691}
	IMDbID  string // From {imdb-tt1234567}
	TVDbID  int    // From [tvdb-123] or [tvdbid-123]
	Edition string // From {edition-Extended}
}

type TorrentAdder interface {
	AddTorrent(ctx context.Context, instanceID int, fileContent []byte, options map[string]string) error
	BulkAction(ctx context.Context, instanceID int, hashes []string, action string) error
	ResumeWhenComplete(instanceID int, hashes []string, opts qbsync.ResumeWhenCompleteOptions)
}

type TorrentChecker interface {
	HasTorrentByAnyHash(ctx context.Context, instanceID int, hashes []string) (*qbt.Torrent, bool, error)
}

type TorrentFile struct {
	Path   string // Relative path within the torrent
	Size   int64  // Size in bytes
	Offset int64  // Byte offset in the torrent's byte stream (for piece calculation)
}