parser

type ExtractedFileInfo struct {
	Name string `json:"name"`
	Size int64  `json:"size"`
}

type FirstSegmentData struct {
	File                *nzbparser.NzbFile // Reference to the NZB file (for groups, subject, metadata)
	Headers             nntppool.YEncMeta  // yEnc headers (FileName, FileSize, PartSize)
	RawBytes            []byte             // Up to 16KB of raw data for PAR2 detection (may be less if segment is smaller)
	MissingFirstSegment bool               // True if first segment download failed (article not found, etc.)
	IsArticleNotFound   bool               // True only when 430 Not Found (permanent); false for timeouts/transient
	SkippedFirstSegment bool               // True when the fetch was intentionally skipped (clean-named multipart file); Headers/RawBytes are empty by design, not by failure
	OriginalIndex       int                // Original position in the parsed NZB file list
	// FirstArticleMissingID is set when the first article is gone but the yEnc
	// header was recovered from a later one. Headers are valid (PartSize is the
	// derived first-part size); RawBytes is empty, so magic-byte and PAR2
	// Hash16k matching are unavailable for this file.
	FirstArticleMissingID string
}

type NzbType string

type ParseOptions struct {
	// BrokenFileIndexes contains the 0-based positions (in the Nzb.Files slice)
	// of files whose sampled segments failed a pre-parse Stat check. Their first
	// segments are short-circuited to MissingFirstSegment=true without a Body call.
	BrokenFileIndexes map[int]struct{}
	// KnownMissingSegmentIDs seeds notFoundIDs so yEnc normalisation and 16KB
	// completion never re-issue Stat/Body calls for already-known-missing IDs.
	KnownMissingSegmentIDs map[string]struct{}
}

type ParsedFile struct {
	Subject          string
	Filename         string
	OriginalFilename string // Recovered posted name before import/display renaming.
	Size             int64
	Segments         []*metapb.SegmentData
	SegmentRefs      []*metapb.SegmentRef // v3: refs into NzbStore (populated when Store != nil)
	Groups           []string
	IsRarArchive     bool
	Is7zArchive      bool
	IsPar2Archive    bool
	Encryption       metapb.Encryption // Encryption type (e.g., "rclone"), nil if not encrypted
	Password         string            // Password from NZB meta, nil if not encrypted
	Salt             string            // Salt from NZB meta, nil if not encrypted
	ReleaseDate      time.Time         // Release date from the Usenet post
	OriginalIndex    int               // Original position in the parsed NZB file list
	NzbdavID         string            // Original ID from nzbdav (for backward compatibility)
	AesKey           []byte            // AES encryption key (for nzbdav compatibility)
	AesIv            []byte            // AES initialization vector (for nzbdav compatibility)

	// FirstSegmentBytes holds the decoded leading bytes (≤16KB) of this file's first
	// segment, captured when the parser fetched it during first-segment analysis. It
	// lets the archive analysis phase (UsenetFileSystem) serve a volume's header read,
	// which starts at offset 0, from memory instead of re-fetching a segment already
	// pulled over the wire this import. Empty when the first segment was skipped/missing
	// or for files built outside the parser — those paths fall through to the network.
	// Transient (not persisted); valid only for the lifetime of the import.
	FirstSegmentBytes []byte
}

type ParsedNzb struct {
	Path          string
	Filename      string
	TotalSize     int64
	Type          NzbType
	Files         []ParsedFile
	SegmentsCount int

	ExtractedFiles []ExtractedFileInfo
	Store          *metapb.NzbStore // NzbStore for this release (built at parse time)
	SegmentIndex   map[string]int64 // message-id → flat store index
	// DegradedFiles maps a parsed filename to the message-id of its dead first
	// article, for files whose header was recovered from a later article. The
	// processor merges it into the repair queue so the hole gets patched.
	DegradedFiles map[string]string
	// contains filtered or unexported fields
}

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

type SegmentStore interface {
	Get(messageID string) ([]byte, bool)
	Put(messageID string, data []byte) error
}

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