avatarr-parser 0.1.0

// Ported from Sonarr v4.0.17.2952 (97e85a90):
//   src/NzbDrone.Core/Parser/Parser.cs — ReportTitleRegex[] + pre-processing regexes
//
// Each Lazy<Regex> is annotated with its Sonarr array index and Parser.cs line
// number. The cascade is order-dependent (first match wins), so indices must be
// preserved for verification by inspection.
//
// LOOKAROUND REMOVAL STRATEGY:
// - `(?<!\d+)` / `(?!\d+)` on season/episode: dropped. The greedy quantifier
//   already consumes max digits. Boundary validated post-match when needed.
// - `(?<![()[\]!])` after `[-_\W]`: replaced with `[^a-zA-Z0-9()[\]!]`
//   (same character class minus brackets/parens/exclamation).
// - `(?!\\)` at end of pattern: dropped (no backslash paths in our input).
// - `(?=...)` lookaheads: dropped; constraint checked post-match.
// - `(?>...)` atomic groups: replaced with `(?:...)`.

use once_cell::sync::Lazy;
use regex::Regex;

// ---------------------------------------------------------------------------
// Pre-processing regexes (applied before the cascade)
// ---------------------------------------------------------------------------

/// Parser.cs:529 — strip file extensions (.mkv, .avi, etc.)
pub static FILE_EXTENSION_REGEX: Lazy<Regex> =
    Lazy::new(|| Regex::new(r"(?i)\.[a-z0-9]{2,4}$").expect("FILE_EXTENSION_REGEX"));

/// Parser.cs:532-534 — strip resolution/codec tokens for title extraction.
///
/// C# `(?<![a-f0-9])` before 8/10-bit: dropped (rare false positive).
/// C# `(?![a-z0-9])` after `b` in 8b/10b: dropped; `bit` branch covers.
pub static SIMPLE_TITLE_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)(?:(?:480|540|576|720|1080|2160)[ip]|[xh][\W_]?26[45]|DD\W?5\W1|[<>?*]|848x480|1280x720|1920x1080|3840x2160|4096x2160|(?:8|10)bit|10-bit)\s*?",
    )
    .expect("SIMPLE_TITLE_REGEX")
});

/// Parser.cs:538-540 — strip website prefix like `[www.site.com] -`
///
/// C# `(?<!Naruto-Kun\.)` lookbehind: dropped. Naruto-Kun is an edge case
/// that would false-positive strip the site from a legitimate anime release.
pub static WEBSITE_PREFIX_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)^(?:(?:\[|\()\s*)?(?:www\.)?[-a-z0-9-]{1,256}\.(?:[a-z]{2,6}\.[a-z]{2,6}|xn--[a-z0-9-]{4,}|[a-z]{2,})\b(?:\s*(?:\]|\))|[ -]{2,})[ -]*",
    )
    .expect("WEBSITE_PREFIX_REGEX")
});

/// Parser.cs:542-544 — strip trailing website suffix
pub static WEBSITE_POSTFIX_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)(?:\[\s*)?(?:www\.)?[-a-z0-9-]{1,256}\.(?:xn--[a-z0-9-]{4,}|[a-z]{2,6})\b(?:\s*\])$",
    )
    .expect("WEBSITE_POSTFIX_REGEX")
});

/// Parser.cs:553-555 — strip torrent tracker suffixes
pub static CLEAN_TORRENT_SUFFIX_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)\[(?:ettv|rartv|rarbg|cttv|publichd)\]$").expect("CLEAN_TORRENT_SUFFIX_REGEX")
});

/// Parser.cs:557-558 — trailing quality brackets like `[x264-720p]`
pub static CLEAN_QUALITY_BRACKETS_REGEX: Lazy<Regex> =
    Lazy::new(|| Regex::new(r"(?i)\[[a-z0-9 ._-]+\]$").expect("CLEAN_QUALITY_BRACKETS_REGEX"));

/// Parser.cs:521 — detect reversed titles (e.g. `p0801` = 1080p backwards)
pub static REVERSED_TITLE_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)(?:^|[-. _])(?:p027|p0801|\d{2,3}E\d{2}S)[-. _]")
        .expect("REVERSED_TITLE_REGEX")
});

/// Parser.cs:546-547 — 6-digit air date (e.g. 210415 = 2021-04-15)
///
/// C# uses lookbehinds `(?<=[_.-])` and `(?=[_.-])`. Replaced with
/// explicit capture groups for the surrounding separators.
pub static SIX_DIGIT_AIR_DATE_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?P<prefix>[_.+-])(?P<airdate>(?P<airyear>[1-9]\d)(?P<airmonth>0[1-9]|1[0-2])(?P<airday>0[1-9]|[12]\d|3[01]))(?P<suffix>[_.+-])",
    )
    .expect("SIX_DIGIT_AIR_DATE_REGEX")
});

/// Parser.cs:589 — strip `[request info]` prefixes from series titles
pub static REQUEST_INFO_REGEX: Lazy<Regex> =
    Lazy::new(|| Regex::new(r"^\[.+?\]").expect("REQUEST_INFO_REGEX"));

/// Parser.cs:56 — Spanish releases with info in brackets (PreSubstitution[11])
///
/// C# `(?=[ ._-]\()` lookahead in title: replaced by splitting the match.
pub static PRE_SUB_SPANISH_REGEX: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[ ._-]\(.+?\((?P<year>\d{4})/(?P<info>S[^/]+)")
        .expect("PRE_SUB_SPANISH_REGEX")
});

// ---------------------------------------------------------------------------
// Hashed-release rejection regexes (ValidateBeforeParsing)
// ---------------------------------------------------------------------------

pub static REJECT_HASHED_REGEXES: Lazy<Vec<Regex>> = Lazy::new(|| {
    [
        r"^[0-9a-zA-Z]{32}",
        r"(?i)^[a-z0-9]{24}$",
        r"^[A-Z]{11}\d{3}$",
        r"(?i)^[a-z]{12}\d{3}$",
        r"^Backup_\d{5,}S\d{2}-\d{2}$",
        r"^123$",
        r"(?i)^abc$",
        r"(?i)^abc[-_. ]xyz",
        r"(?i)^b00bs$",
        r"^\d{6}_\d{2}$",
        r"^[0-9a-zA-Z]{30}",
        r"^[0-9a-zA-Z]{26}",
        r"^[0-9a-zA-Z]{39}",
        r"^[0-9a-zA-Z]{24}",
    ]
    .iter()
    .map(|p| Regex::new(p).expect("REJECT_HASHED_REGEX"))
    .collect()
});

/// Parser.cs:515-518 — season folder names to reject
pub static SEASON_FOLDER_REGEXES: Lazy<Vec<Regex>> = Lazy::new(|| {
    [
        r"(?i)^(?:S|Season|Saison|Series|Stagione)[-_ ]*\d{1,4}\s*$",
        r"(?i)^Specials?$",
    ]
    .iter()
    .map(|p| Regex::new(p).expect("SEASON_FOLDER_REGEX"))
    .collect()
});

// ---------------------------------------------------------------------------
// Separator character class
// ---------------------------------------------------------------------------
//
// C# `[-_\W](?<![()[\]!])` = "non-alphanumeric except brackets/parens/bang"
// Rust equivalent: `[^a-zA-Z0-9()[\]!]`
//
// In patterns below, `SEP` in comments means this class. The actual regex
// inline uses `[^a-zA-Z0-9()\\[\\]!]` or the shorthand where context allows.

// ---------------------------------------------------------------------------
// ReportTitleRegex[] cascade — m52 + m53 scope
// ---------------------------------------------------------------------------

/// Helper struct pairing a compiled regex with its Sonarr index.
pub struct IndexedRegex {
    pub index: u8,
    pub regex: &'static Lazy<Regex>,
}

// -- Daily / leading-date patterns (indices 0-1) --

/// Sonarr ReportTitleRegex[0]: Parser.cs:67-68
/// Plex DVR format: daily with year in series title, air time after date.
///
/// C# `^^` typo → single `^`. C# `\k<sep>` backreference → dual `sep1`/`sep2`
/// captures; equality validated post-match in `try_regex()`.
pub static REGEX_00: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?\((?P<titleyear>\d{4})\))[-_. ]+(?P<airyear>19[4-9]\d|20\d\d)(?P<sep1>[-_]?)(?P<airmonth>0\d|1[0-2])(?P<sep2>[-_]?)(?P<airday>[0-2]\d|3[01])[-_. ]\d{2}[-_. ]\d{2}[-_. ]\d{2}")
        .expect("REGEX_00")
});

/// Sonarr ReportTitleRegex[1]: Parser.cs:71-72
/// Daily episodes without title (2018-10-12, 20181012) — strict pattern.
///
/// C# `\k<sep>` → dual sep captures. C# `(?!\d)` after airday → post-match
/// `digit_boundary_ok` on airday.
pub static REGEX_01: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<airyear>19[6-9]\d|20\d\d)(?P<sep1>[-_]?)(?P<airmonth>0\d|1[0-2])(?P<sep2>[-_]?)(?P<airday>[0-2]\d|3[01])")
        .expect("REGEX_01")
});

// -- Titleless patterns (indices 2-6) --

/// Sonarr ReportTitleRegex[2]: Parser.cs:75-76
/// Multi-Part without title: S01E05.S01E06
pub static REGEX_02: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\W*S(?P<season>\d{1,2}|\d{4})(?:e{1,2}(?P<ep>\d{1,3}))+){2,}")
        .expect("REGEX_02")
});

/// Sonarr ReportTitleRegex[3]: Parser.cs:79-80
/// Multi-Part without title: 1x05.1x06
pub static REGEX_03: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\W*(?P<season>\d{1,2}|\d{4})(?:x{1,2}(?P<ep>\d{1,3}))+){2,}")
        .expect("REGEX_03")
});

/// Sonarr ReportTitleRegex[4]: Parser.cs:83-84
/// Without title, multi: S01E04E05
pub static REGEX_04: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:S?(?P<season>\d{1,2}|\d{4})(?:(?:[-_]|[ex]){1,2}(?P<ep>\d{2,3})){2,})")
        .expect("REGEX_04")
});

/// Sonarr ReportTitleRegex[5]: Parser.cs:87-88
/// Split episodes: S01E05a
pub static REGEX_05: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:S?(?P<season>\d{1,2}|\d{4})(?:(?:[-_ ]?[ex])(?P<ep>\d{2,3})(?P<splitepisode>[a-d])(?:[ _.])))")
        .expect("REGEX_05")
});

/// Sonarr ReportTitleRegex[6]: Parser.cs:91-92
/// Without title, single: S01E05, 1x05
pub static REGEX_06: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:S?(?P<season>\d{1,2}|\d{4})(?:(?:[-_ ]?[ex])(?P<ep>\d{2,3})))")
        .expect("REGEX_06")
});

// -- Absolute/anime patterns (indices 7-21, 26, 28-32) --

/// Sonarr ReportTitleRegex[7]: Parser.cs:95-96
/// Anime - [SubGroup] Title Absolute (Season+Episode)
///
/// C# duplicate `absoluteepisode` allowed; Rust uses `absoluteepisode` only (single).
/// Lookarounds dropped. `(?>...)` atomic group → `(?:...)`.
pub static REGEX_07: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\](?:_|-|\s|\.)?\s*(?P<title>.+?)[-_. ]+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)(?:[-_. ])+\((?:S(?P<season>\d{1,2})(?:(?:[ex]|\W[ex]){1,2}(?P<episode>\d{2})))(?:v\d+)?(?:\)).*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_07")
});

/// Sonarr ReportTitleRegex[8]: Parser.cs:99-100
/// Anime - [SubGroup] Title Absolute - Season+Episode
///
/// C# `(?<![()\[!])` after `[-_. ]` → `[^a-zA-Z0-9()\[\]!]` in separator.
pub static REGEX_08: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\](?:_|-|\s|\.)?\s*(?P<title>.+?)[-_. ]+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)(?:[^a-zA-Z0-9()\[\]!])+(?:S(?P<season>\d{1,2})(?:(?:[ex]|\W[ex]){1,2}(?P<episode>\d{2})))(?:v\d+)?(?:[_. ]).*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_08")
});

/// Sonarr ReportTitleRegex[10]: Parser.cs:103-104
/// Anime - [SubGroup] Title Season+Episode (no absolute)
///
/// This is parsed as absolute because Sonarr indexes it that way,
/// but it only has season+episode captures, no absoluteepisode.
/// We handle it as a standard S##E## pattern in try_regex dispatch.
pub static REGEX_10: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\](?:_|-|\s|\.)?\s*(?P<title>.+?)(?:[^a-zA-Z0-9()\[\]!])+(?:S?(?P<season>\d{1,2})(?:(?:[ex]|\W[ex]){1,2}(?P<episode>\d{2}))+)(?:v\d+)?(?:[_. ]).*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_10")
});

/// Sonarr ReportTitleRegex[11]: Parser.cs:107-108
/// Anime - [SubGroup] Title Episode Absolute Episode Number
pub static REGEX_11: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?)[-_. ]+?(?:Episode)(?:[-_. ]+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+.*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_11")
});

/// Sonarr ReportTitleRegex[12]: Parser.cs:111-112
/// Anime - [SubGroup] Title Absolute Episode Number + Season+Episode
pub static REGEX_12: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\](?:_|-|\s|\.)?\s*(?P<title>.+?)(?:(?:[^a-zA-Z0-9()\[\]!])+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+(?:_|-|\s|\.)+(?:S?(?P<season>\d{1,2})(?:(?:[-]|[ex]|\W[ex]){1,2}(?P<episode>\d{2}))+).*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.)$")
        .expect("REGEX_12")
});

/// Sonarr ReportTitleRegex[13]: Parser.cs:115-116
/// Anime - [SubGroup] Title Season+Episode + Absolute Episode Number
///
/// C# `(?!\d+|\-[a-z])` after absolute: dropped, handled by digit_boundary_ok.
pub static REGEX_13: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\](?:_|-|\s|\.)?\s*(?P<title>.+?)(?:[^a-zA-Z0-9()\[\]!])+(?:S?(?P<season>\d{1,2})(?:(?:[-]|[ex]|\W[ex]){1,2}(?P<episode>\d{2}))+)(?:(?:_|-|\s|\.)+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+.*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_13")
});

/// Sonarr ReportTitleRegex[14]: Parser.cs:119-120
/// Anime - [SubGroup] Title with trailing number - Batch separated with tilde
///
/// C# has duplicate `absoluteepisode` groups. Rust uses `absoluteepisode` + `absoluteepisode2`.
/// C# `(?<![-_. ]|\b[0]\d+) - ` → we drop the lookbehind.
pub static REGEX_14: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?[^-]+?) - [-_. ]?(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)\s?~\s?(?P<absoluteepisode2>\d{2,3}(?:\.\d{1,2})?)(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_14")
});

/// Sonarr ReportTitleRegex[15]: Parser.cs:123-124
/// Anime - [SubGroup] Title with season number in brackets Absolute Episode Number
pub static REGEX_15: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>[^-]+?)[_. ]+?\(Season[_. ](?P<season>\d+)\)[-_. ]+?(?:[-_. ]?(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_15")
});

/// Sonarr ReportTitleRegex[16]: Parser.cs:127-128
/// Anime - [SubGroup] Title with trailing 3-digit number and sub title - Absolute Episode Number
///
/// C# `(?!-?\d+|-[a-z]+)` after absolute: dropped, handled by digit_boundary_ok.
/// C# `[-_. ]{3}?` → 3 consecutive separators.
pub static REGEX_16: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>[^\]]+?)(?:[-_. ]{3}(?P<absoluteepisode>\d{2}(?:\.\d{1,2})?))+(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_16")
});

/// Sonarr ReportTitleRegex[17]: Parser.cs:151-152
/// Anime - [SubGroup] Title Absolute Episode Number (with optional `#` prefix
/// or parentheses wrapping the episode number).
///
/// The C# regex uses a repeating `absoluteepisode` group and takes `.Last()`.
/// In Rust, repeating named groups only keep the last value (which the regex
/// engine minimizes to the first match due to lazy `title`). We split into
/// three sub-patterns:
///
/// - REGEX_17A: `#NNN` prefix (required `#`) — unique to this pattern.
/// - REGEX_17B: parenthesized range `(NN-MM)` — anime batch releases.
/// - REGEX_17C: general catch-all `Title NNN` — placed AFTER REGEX_18-21
///   in the cascade so dash-separated patterns (`Title - NNN`) are handled
///   by the more specific patterns first. In Rust the `+` loop keeps only
///   the first match due to lazy `title`, which matches Sonarr's `.First()`
///   (which equals `.Last()` for single-capture cases).
pub static REGEX_17A: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?)[-_. ]+#(?P<absoluteepisode>\d{2,4}(?:\.\d{1,2})?)(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_17A")
});

/// REGEX_17B: parenthesized absolute range — `[SubGroup] Title (01-25)`
pub static REGEX_17B: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?)[-_. ]+\((?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)-(?P<absoluteepisode2>\d{2,3}(?:\.\d{1,2})?)\)(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_17B")
});

/// REGEX_17C: general [SubGroup] Title NNN (optional `#`, no dash separator)
///
/// Placed AFTER REGEX_18-21 in the cascade. Handles remaining cases where
/// the absolute episode number follows the title with a simple separator.
pub static REGEX_17C: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?)[-_. ]+\(?#?(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)\)?(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_17C")
});

/// Sonarr ReportTitleRegex[18]: Parser.cs:131-132
/// Anime - [SubGroup] Title with trailing number Absolute Episode Number
///
/// C# `(?<![-_. ]|\b[0]\d+) - ` → drop lookbehind.
pub static REGEX_18: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>[^-]+?) - (?:[-_. ]?(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_18")
});

/// Sonarr ReportTitleRegex[19]: Parser.cs:139-140
/// Anime - [SubGroup] Title with trailing number Absolute Episode Number (3-digit only)
///
/// C# `(?<![-_. ]|\b[0]\d+)[_ ]+` → drop lookbehind.
pub static REGEX_19: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>[^-]+?)[_ ]+(?:[-_. ]?(?P<absoluteepisode>\d{3}(?:\.\d{1,2})?))+(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_19")
});

/// Sonarr ReportTitleRegex[20]: Parser.cs:143-144
/// Anime - [SubGroup] Title - Absolute Episode Number
///
/// C# `(?<!\b[0]\d+)` → drop lookbehind.
pub static REGEX_20: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?)(?:[. ]-[. ](?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_20")
});

/// Sonarr ReportTitleRegex[21]: Parser.cs:147-148
/// Anime - [SubGroup] Title Absolute - Absolute (batch without full separator)
///
/// C# duplicate `absoluteepisode` → `absoluteepisode` + `absoluteepisode2`.
pub static REGEX_21: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?)(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)[. ]-[. ](?P<absoluteepisode2>\d{2,3}(?:\.\d{1,2})?)(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])?(?:$|\.mkv)")
        .expect("REGEX_21")
});

/// Sonarr ReportTitleRegex[26]: Parser.cs:171-172
/// Anime - Title Season EpisodeNumber + Absolute Episode Number [SubGroup]
///
/// C# `(?!\d+|[pi])` after absolute: dropped (boundary check).
pub static REGEX_26: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:[^a-zA-Z0-9()\[\]!])+(?:S?(?P<season>\d{1,2})(?:(?:[ex]|\W[ex]|-){1,2}(?P<episode>\d{2}))+)[-_. (]+?(?:[-_. ]?(?P<absoluteepisode>\d{3}(?:\.\d{1,2})?))+.+?\[(?P<subgroup>.+?)\](?:$|\.mkv)")
        .expect("REGEX_26")
});

/// Sonarr ReportTitleRegex[28]: Parser.cs:179-180
/// Anime - Title Absolute Episode Number [SubGroup] [Hash]?
pub static REGEX_28: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[-_. ]Episode(?:[-_. ]+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+(?:.+?)\[(?P<subgroup>.+?)\].*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_28")
});

/// Sonarr ReportTitleRegex[29]: Parser.cs:183-184
/// Anime - Title Absolute Episode Number [SubGroup] [Hash]
/// Note: C# requires decimal `(\.\d{1,2})` (not optional) — so this only matches decimals.
pub static REGEX_29: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:(?:_|-|\s|\.)+(?P<absoluteepisode>\d{3}(?:\.\d{1,2})))+(?:.+?)\[(?P<subgroup>.+?)\].*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_29")
});

/// Sonarr ReportTitleRegex[30]: Parser.cs:187-188
/// Anime - Title Absolute Episode Number (Year) [SubGroup]
pub static REGEX_30: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[-_. ]+(?P<absoluteepisode>\d{2})[-_. ]\(\d{4}\)[-_. ]\[(?P<subgroup>.+?)\]")
        .expect("REGEX_30")
});

/// Sonarr ReportTitleRegex[31]: Parser.cs:191-192
/// Anime - Title with trailing number, Absolute Episode Number and hash
///
/// C# `(?<![-_. ]|\b[0]\d+) - ` → drop lookbehind.
pub static REGEX_31: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>[^-]+?) - (?:[-_. ]?(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+(?:[-_. ]+(?P<special>special|ova|ovd))?.*?(?P<hash>[(\[]\w{8}[)\]])(?:$|\.mkv)")
        .expect("REGEX_31")
});

/// Sonarr ReportTitleRegex[32]: Parser.cs:195-196
/// Anime - Title Absolute Episode Number [Hash]
pub static REGEX_32: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:(?:_|-|\s|\.)+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+(?:[-_. ]+(?P<special>special|ova|ovd))?[-_. ]+.*?(?P<hash>[(\[]\w{8}[)\]])$")
        .expect("REGEX_32")
});

// -- Daily patterns (indices 34-35, 49, 76, 78-80) --

/// Sonarr ReportTitleRegex[34]: Parser.cs:203-204
/// Decomposed airdate AND season/episode: `Title YYYY MM DD S##E##`
///
/// C# `(?!\W+[0-3][0-9])` after airday: dropped, post-match `trailing_day_after`.
pub static REGEX_34: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)?\W*(?P<airyear>\d{4})\W+(?P<airmonth>[0-1][0-9])\W+(?P<airday>[0-3][0-9]).+?(?:s?(?P<season>\d{1,2}))(?:[ex](?P<ep>\d{1,3}))")
        .expect("REGEX_34")
});

/// Sonarr ReportTitleRegex[35]: Parser.cs:207-208
/// TJET Wrestling: absolute+airdate pattern.
///
/// C# `(?!\W+[0-3][0-9])` after airday: dropped, post-match `trailing_day_after`.
pub static REGEX_35: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)?[-_. ](?:e\d{2,3})[-_. ](?P<airyear>\d{4})\W+(?P<airmonth>[0-1][0-9])\W+(?P<airday>[0-3][0-9]).+?(?:\[[a-z]+\])")
        .expect("REGEX_35")
});

/// Sonarr ReportTitleRegex[49]: Parser.cs:263-264
/// Episodes with airdate and part (2018.04.28.Part.2)
///
/// C# `(?![-_. ]+[0-3][0-9])` after airday: dropped, post-match `trailing_day_after`.
pub static REGEX_49: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)?\W*(?P<airyear>\d{4})[-_. ]+(?P<airmonth>[0-1][0-9])[-_. ]+(?P<airday>[0-3][0-9])[-_. ]+Part[-_. ]?(?P<part>[1-9])")
        .expect("REGEX_49")
});

/// Sonarr ReportTitleRegex[76]: Parser.cs:375-376
/// Main daily pattern: Episodes with airdate (2018.04.28)
///
/// C# `(?![-_. ]+[0-3][0-9])` after airday: dropped, post-match `trailing_day_after`.
pub static REGEX_76: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)?\W*(?P<airyear>\d{4})[-_. ]+(?P<airmonth>[0-1][0-9])[-_. ]+(?P<airday>[0-3][0-9])")
        .expect("REGEX_76")
});

/// Sonarr ReportTitleRegex[77]: Parser.cs:379
/// Turkish tracker releases (01 BLM, 3. Blm, 04.Bolum, etc)
pub static REGEX_77: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[_. ](?P<absoluteepisode>\d{1,4})(?:[_. ]+)(?:BLM|B[oö]l[uü]m)")
        .expect("REGEX_77")
});

/// Sonarr ReportTitleRegex[78]: Parser.cs:382-383
/// Ambiguous US date: MM.DD.YYYY
pub static REGEX_78: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)?\W*(?P<ambiguousairmonth>[0-1][0-9])[-_. ]+(?P<ambiguousairday>[0-3][0-9])[-_. ]+(?P<airyear>\d{4})")
        .expect("REGEX_78")
});

/// Sonarr ReportTitleRegex[79]: Parser.cs:386-387
/// Ambiguous UK date: DD.MM.YYYY
pub static REGEX_79: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)?\W*(?P<ambiguousairday>[0-3][0-9])[-_. ]+(?P<ambiguousairmonth>[0-1][0-9])[-_. ]+(?P<airyear>\d{4})")
        .expect("REGEX_79")
});

/// Sonarr ReportTitleRegex[80]: Parser.cs:390-391
/// Compact date: YYYYMMDD (no separators between date components)
pub static REGEX_80: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)^(?P<title>.+?)?\W*(?P<airyear>\d{4})(?P<airmonth>[0-1][0-9])(?P<airday>[0-3][0-9])",
    )
    .expect("REGEX_80")
});

// -- More absolute/anime patterns (indices 45-46, 65-67, 81, 87-94) --

/// Sonarr ReportTitleRegex[45]: Parser.cs:247-248
/// Anime - 4 digit absolute episode number (with subgroup)
pub static REGEX_45: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?)[-_. ]+?(?P<absoluteepisode>\d{4}(?:\.\d{1,2})?)")
        .expect("REGEX_45")
});

/// Sonarr ReportTitleRegex[46]: Parser.cs:251-252
/// Anime - Title 4-digit Absolute Episode Number [SubGroup]
pub static REGEX_46: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[-_. ]+(?P<absoluteepisode>\d{4})[-_. ]\[(?P<subgroup>.+?)\]")
        .expect("REGEX_46")
});

/// Sonarr ReportTitleRegex[65]: Parser.cs:329-330
/// Anime - Title with season number - Absolute Episode Number (Title S01 - EP14)
pub static REGEX_65: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)^(?P<title>.+?S\d{1,2})[-_. ]{3,}(?:EP)?(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)",
    )
    .expect("REGEX_65")
});

/// Sonarr ReportTitleRegex[66]: Parser.cs:333-334
/// Anime - French titles with single episode numbers, with or without leading sub group
pub static REGEX_66: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)[-_. ]+?(?:Episode[-_. ]+?)(?P<absoluteepisode>\d{1}(?:\.\d{1,2})?)")
        .expect("REGEX_66")
});

/// Sonarr ReportTitleRegex[67]: Parser.cs:337-338
/// Anime - Absolute episode number in square brackets
pub static REGEX_67: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^\[(?P<subgroup>.+?)\][-_. ]?(?P<title>.+?)[-_. ]+?\[(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)\]")
        .expect("REGEX_67")
});

/// Sonarr ReportTitleRegex[81]: Parser.cs:393-394
/// Anime - Title Absolute Episode Number (E195 or E1206)
pub static REGEX_81: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)(?:(?:_|-|\s|\.)+(?:e|ep)(?P<absoluteepisode>(?:\d{3}|\d{4})(?:\.\d{1,2})?))+[-_. ].*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_81")
});

/// Sonarr ReportTitleRegex[87]: Parser.cs:417-419
/// Anime Range - Title ep01-12
///
/// C# duplicate `absoluteepisode` → `absoluteepisode` + `absoluteepisode2`.
pub static REGEX_87: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)(?:_|\s|\.)+(?:e|ep)(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?)-(?P<absoluteepisode2>\d{1,2}(?:\.\d{1,2})?).*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_87")
});

/// Sonarr ReportTitleRegex[88]: Parser.cs:421-423
/// Anime - Title Absolute Episode Number (e66)
pub static REGEX_88: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)(?:(?:_|-|\s|\.)+(?:e|ep)(?P<absoluteepisode>\d{2,4}(?:\.\d{1,2})?))+[-_. ].*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_88")
});

/// Sonarr ReportTitleRegex[89]: Parser.cs:426-427
/// Anime - Title Episode Absolute Episode Number (Series Title Episode 01)
pub static REGEX_89: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[-_. ](?:Episode)(?:[-_. ]+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+.*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_89")
});

/// Sonarr ReportTitleRegex[90]: Parser.cs:430-431
/// Anime Range - Title Absolute Episode Number (1-2 digit range, 1-10)
///
/// C# duplicate `absoluteepisode` → `absoluteepisode` + `absoluteepisode2`.
pub static REGEX_90: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)[_. ]+(?P<absoluteepisode>\d{1,2}(?:\.\d{1,2})?)-(?P<absoluteepisode2>\d{1,2}(?:\.\d{1,2})?).*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_90")
});

/// Sonarr ReportTitleRegex[91]: Parser.cs:434-435
/// Anime - Title Episode/Episodio Absolute Episode Number
pub static REGEX_91: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)[-_. ]+(?:Episode|Episodio)(?:[-_. ]+(?P<absoluteepisode>\d{2,4}(?:\.\d{1,2})?))+.*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_91")
});

/// Sonarr ReportTitleRegex[92]: Parser.cs:438-439
/// Anime - Title [Absolute Episode Number] from AniLibriaTV
pub static REGEX_92: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)(?:[-_. ]\[)(?:(?:-?)(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+(?:\][-_. ]).*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_92")
});

/// Sonarr ReportTitleRegex[93]: Parser.cs:442-443
/// Anime - Title Absolute Episode Number (catch-all)
pub static REGEX_93: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)(?:[-_. ]+(?P<absoluteepisode>\d{2,4}(?:\.\d{1,2})?))+.*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_93")
});

/// Sonarr ReportTitleRegex[94]: Parser.cs:446-447
/// Anime - Title {Absolute Episode Number} (brace-separated, catch-all)
pub static REGEX_94: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[(?P<subgroup>.+?)\][-_. ]?)?(?P<title>.+?)(?:(?:[^a-zA-Z0-9()\[\]!])+(?P<absoluteepisode>\d{2,3}(?:\.\d{1,2})?))+.*?(?P<hash>[(\[]\w{8}[)\]])?$")
        .expect("REGEX_94")
});

// -- With-title standard patterns --

/// Sonarr ReportTitleRegex[22]: Parser.cs:155-156
/// Multi-episode Repeated: S01E05 - S01E06
pub static REGEX_22: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:[^a-zA-Z0-9()\[\]!]+S(?P<season>\d{1,2}|\d{4})(?:(?:e|[-_. ]e){1,2}(?P<ep>\d{1,3}))+){2,}")
        .expect("REGEX_22")
});

/// Sonarr ReportTitleRegex[23]: Parser.cs:159-160
/// Multi-episode Repeated: 1x05 - 1x06
pub static REGEX_23: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:[^a-zA-Z0-9()\[\]!]+(?P<season>\d{1,2}|\d{4})(?:x{1,2}(?P<ep>\d{1,3}))+){2,}")
        .expect("REGEX_23")
});

/// Sonarr ReportTitleRegex[24]: Parser.cs:163-164
/// Single with ".5 [SP]": S01E03.5 [SP]
pub static REGEX_24: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[^a-zA-Z0-9()\[\]!]+S?(?P<season>\d{1,2})(?:[ex]|\W[ex]|_){1,2}(?P<ep>\d{2,3})(?P<special>\.5[ .]\[SP\])")
        .expect("REGEX_24")
});

/// Sonarr ReportTitleRegex[25]: Parser.cs:167-168
/// Single with trailing slashes: S01E05 [info]
pub static REGEX_25: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[^a-zA-Z0-9()\[\]!]+S?(?P<season>\d{1,2})(?:[ex]|\W[ex]|_){1,2}(?P<ep>\d{2,3}).+?\[.+?\]")
        .expect("REGEX_25")
});

/// Sonarr ReportTitleRegex[27]: Parser.cs:175-176
/// Multi-Episode with trailing slashes
pub static REGEX_27: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[^a-zA-Z0-9()\[\]!]+S?(?P<season>\d{1,2})(?:[ex]|\W[ex]|_){1,2}(?P<ep1>\d{2,3})(?:(?:[-ex]|\W[ex]|_){1,2}(?P<ep2>\d{2,3}))+.+?\[.+?\]")
        .expect("REGEX_27")
});

/// Sonarr ReportTitleRegex[33]: Parser.cs:199-200
/// Airdate AND season/episode — capture S/E only
pub static REGEX_33: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)?\W*\d{4}\W+[0-1][0-9]\W+[0-3][0-9][-_. ](?:s?(?P<season>\d{1,2}))(?:[ex](?P<ep>\d{1,3}))")
        .expect("REGEX_33")
});

/// Sonarr ReportTitleRegex[36]: Parser.cs:211-212
/// Multiple titles / separated, then S#E# (of N)
pub static REGEX_36: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:(?P<title>.*?)[ ._]/[ ._])+\(?S(?P<season>\d{1,2})\W?E?[ ._]?(?P<ep1>\d{1,2})(?:-(?P<ep2>\d{1,2}))?(?:[ ._]of[ ._](?P<episodecount>\d{1,2}))?\)?[ ._][(\[]")
        .expect("REGEX_36")
});

/// Sonarr ReportTitleRegex[37]: Parser.cs:215-216
/// Multi-episode: S01E99-100
pub static REGEX_37: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[^a-zA-Z0-9()\[\]!]+S(?P<season>\d{1,2})E(?P<ep1>\d{2,3})(?:-(?P<ep2>\d{2,3}))+(?:[-_. ]|$)")
        .expect("REGEX_37")
});

/// Sonarr ReportTitleRegex[38]: Parser.cs:219-220
/// Multi-episode: S01E05-06, S01E05-6
pub static REGEX_38: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[^a-zA-Z0-9()\[\]!]+S(?P<season>\d{1,2})E(?P<ep1>\d{1,2})(?:-(?P<ep2>\d{1,2}))+(?:[-_. ]|$)")
        .expect("REGEX_38")
});

/// Sonarr ReportTitleRegex[39]: Parser.cs:223-224
/// Single & multi: S01E05, 1x05, S01E05E06
pub static REGEX_39: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:[^a-zA-Z0-9()\[\]!]+S?(?P<season>\d{1,2})(?:[ex]|\W[ex]){1,2}(?P<ep1>\d{2,3})(?:(?:[-ex]|\W+[ex]|_){1,2}(?P<ep2>\d{2,3}))*)(?:[-_. ]|$)")
        .expect("REGEX_39")
});

/// Sonarr ReportTitleRegex[40]: Parser.cs:227-228
/// 4-digit season: S2016E05
pub static REGEX_40: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[^a-zA-Z0-9()\[\]!]+S(?P<season>\d{4})(?:e|\We|_){1,2}(?P<ep1>\d{2,4})(?:(?:[-e]|\We|_){1,2}(?P<ep2>\d{2,3}))*\W?")
        .expect("REGEX_40")
});

/// Sonarr ReportTitleRegex[41]: Parser.cs:231-232
/// 4-digit season with x: 2016x05
pub static REGEX_41: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[^a-zA-Z0-9()\[\]!]+(?P<season>\d{4})(?:x|\Wx){1,2}(?P<ep1>\d{2,4})(?:(?:[-x]|\Wx|_){1,2}(?P<ep2>\d{2,3}))*\W?")
        .expect("REGEX_41")
});

/// Sonarr ReportTitleRegex[42]: Parser.cs:235-236
/// Single: s01.05
pub static REGEX_42: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)^(?P<title>.+?)[^a-zA-Z0-9()\[\]!]+S(?P<season>\d{2})\.(?P<ep>\d{2,3})(?:[-_. ]|$)",
    )
    .expect("REGEX_42")
});

/// Sonarr ReportTitleRegex[43]: Parser.cs:239-240
/// Multi-season pack
pub static REGEX_43: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:Complete Series)?[-_. ]+(?:S|(?:Season|Saison|Series|Stagione)[_. ])(?P<season1>\d{1,2})(?:[-_. ]{1,3})(?:S|(?:Season|Saison|Series|Stagione)[_. ])?(?P<season2>\d{1,2})")
        .expect("REGEX_43")
});

/// Sonarr ReportTitleRegex[44]: Parser.cs:243-244
/// Partial season pack
pub static REGEX_44: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:\W+S(?P<season>\d{1,2})\W+(?:(?:(?:Part|Vol|P)\W?)(?P<seasonpart>\d{1,2}))+)")
        .expect("REGEX_44")
});

/// Sonarr ReportTitleRegex[47]: Parser.cs:255-256
/// Mini-Series with year, Part01
pub static REGEX_47: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?\d{4})(?:\W+(?:(?:Part\W?|e)(?P<ep>\d{1,2}))+)")
        .expect("REGEX_47")
});

/// Sonarr ReportTitleRegex[48]: Parser.cs:259-260
/// Mini-Series, E1-E2
pub static REGEX_48: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:[-. _][e])(?P<ep1>\d{2,3})(?:(?:-?[e])(?P<ep2>\d{2,3}))+")
        .expect("REGEX_48")
});

/// Sonarr ReportTitleRegex[50]: Parser.cs:267-268
/// Mini-Series Part01/Part 01
pub static REGEX_50: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:\W+(?:(?:Part\W?)(?P<ep>\d{1,2}))+)").expect("REGEX_50")
});

/// Sonarr ReportTitleRegex[51]: Parser.cs:271-272
/// Mini-Series Part One/Two/.../Nine
///
/// C# `(?>[-. _])` atomic group → `(?:[-. _])`.
pub static REGEX_51: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:\W+(?:Part[-. _](?P<ep>One|Two|Three|Four|Five|Six|Seven|Eight|Nine)(?:[-. _])))")
        .expect("REGEX_51")
});

/// Sonarr ReportTitleRegex[52]: Parser.cs:275-276
/// Mini-Series XofY
pub static REGEX_52: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:\W+(?:(?P<ep>\d{1,2})of\d+)+)").expect("REGEX_52")
});

/// Sonarr ReportTitleRegex[53]: Parser.cs:279-280
/// Season 01 Episode 03
pub static REGEX_53: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r#"(?i)(?:.*(?:"|^))(?P<title>.*?)(?:[-_\W][^()\[\]])*(?:\W?Season\W?)(?P<season>\d{1,2})(?:\W|_)+(?:Episode\W)(?:[-_. ]?(?P<ep>\d{1,2}))+"#)
        .expect("REGEX_53")
});

/// Sonarr ReportTitleRegex[54]: Parser.cs:283-284
/// Multi-episode in square brackets: [S01E11E12]
pub static REGEX_54: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.*?)[-. _]+\[S(?P<season>\d{2})(?:[E-]{1,2}(?P<ep>\d{2}))+\]")
        .expect("REGEX_54")
});

/// Sonarr ReportTitleRegex[55]: Parser.cs:287-288
/// Multi-episode in parentheses: (S01E11E12)
pub static REGEX_55: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.*?)[-. _]+\(S(?P<season>\d{2})(?:[E-]{1,2}(?P<ep>\d{2}))+\)")
        .expect("REGEX_55")
});

/// Sonarr ReportTitleRegex[56]: Parser.cs:291-292
/// Multi-episode, no space: S01E11E12
pub static REGEX_56: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.*?)S(?P<season>\d{2})(?:E(?P<ep>\d{2}))+").expect("REGEX_56")
});

/// Sonarr ReportTitleRegex[57]: Parser.cs:295-296
/// Multi-episode with single-digit: S6.E1-E2
pub static REGEX_57: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[-_. ]S(?P<season>\d{1,2}|\d{4})(?:(?:[-_. ]?[ex]|[-_. ])(?P<ep>\d{1,2}))+")
        .expect("REGEX_57")
});

/// Sonarr ReportTitleRegex[59]: Parser.cs:303-304
/// Single: S1E1 or S1-E1 or S01.Ep.01
pub static REGEX_59: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r#"(?i)(?:.*(?:"| / |^))(?P<title>.*?)(?:\W?|_)S(?P<season>\d{1,2})(?:\W|_)?Ep?[ ._]?(?P<ep>\d{1,2})(?:[-]\d+)*"#)
        .expect("REGEX_59")
});

/// Sonarr ReportTitleRegex[60]: Parser.cs:307-308
/// 3-digit season: S010E05
pub static REGEX_60: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r#"(?i)(?:.*(?:"|^))(?P<title>.*?)(?:\W?|_)S(?P<season>\d{3})(?:\W|_)?E(?P<ep>\d{1,2})"#,
    )
    .expect("REGEX_60")
});

/// Sonarr ReportTitleRegex[61]: Parser.cs:311-312
/// 5-digit episode: S01E00001
pub static REGEX_61: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:(?P<title>.+?)(?:_|-|\s|\.)+)(?:S?(?P<season>\d{1,2}))(?:(?:[-ex]|\W[ex]|_){1,2}(?P<ep>\d{5}))")
        .expect("REGEX_61")
});

/// Sonarr ReportTitleRegex[62]: Parser.cs:315-316
/// 5-digit multi-episode
pub static REGEX_62: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:(?P<title>.+?)(?:_|-|\s|\.)+)(?:S?(?P<season>\d{1,2}))(?:(?:[-_. ]{1,3}ep){1,2}(?P<ep>\d{5}))+")
        .expect("REGEX_62")
});

/// Sonarr ReportTitleRegex[63]: Parser.cs:319-320
/// Separated: S01 - E01
pub static REGEX_63: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:_|-|\s|\.)+S(?P<season>\d{2})\W-\WE(?P<ep>\d{2})")
        .expect("REGEX_63")
});

/// Sonarr ReportTitleRegex[64]: Parser.cs:325-326
/// Square brackets: [02x01]
pub static REGEX_64: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)?[^a-zA-Z0-9()\[\]!]+\[(?:s)?(?P<season>\d{1,2})(?:(?:[ex])(?P<ep1>\d{2}))(?:(?:[-ex]){1,2}(?P<ep2>\d{2}))*\].+?(?:\.|$)")
        .expect("REGEX_64")
});

/// Sonarr ReportTitleRegex[68]: Parser.cs:341-342
/// Japanese variety shows with leading 6-digit date (YYMMDD)
///
/// C# `(?![-_. ]+[0-3][0-9])` after airday: dropped (post-match validation
/// would be needed but the rest of the pattern is specific enough).
pub static REGEX_68: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<airyear>\d{2})(?P<airmonth>[0-1][0-9])(?P<airday>[0-3][0-9])[-_. ](?P<title>.+?)[-_. ](?:Season[-_. ]?(?P<season>\d{1,2})[-_. ])?(?:ep|#)(?P<ep>\d{1,5})")
        .expect("REGEX_68")
});

// -- Season-only patterns --

/// Sonarr ReportTitleRegex[69]: Parser.cs:345-346
/// Season only followed by year
///
/// C# `(?=[-_. ]\d{4}[-_. ]+)` lookahead: replaced with explicit match
/// of the year pattern after the season.
pub static REGEX_69: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[-_. ]+?(?:S|Season|Saison|Series|Stagione)[-_. ]?(?P<season>\d{1,2})[-_. ]\d{4}[-_. ]")
        .expect("REGEX_69")
});

/// Sonarr ReportTitleRegex[70]: Parser.cs:349-350
/// Season only releases
///
/// C# `(?![-_. ]?\d+)` after season digits: ensures season number isn't
/// followed by more digits. Replaced by requiring a separator or end.
pub static REGEX_70: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+)[-_. /]+(?:S|Season|Saison|Series|Stagione)[-_. ]?(?P<season>\d{1,2})(?:[-_. /]|$)+(?P<extras>EXTRAS|SUBPACK)?")
        .expect("REGEX_70")
});

/// Sonarr ReportTitleRegex[71]: Parser.cs:353-354
/// 4-digit season only
pub static REGEX_71: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[-_. ]+?(?:S|Season|Saison|Series|Stagione)[-_. ]?(?P<season>\d{4})(?:\W+|_|$)(?P<extras>EXTRAS|SUBPACK)?")
        .expect("REGEX_71")
});

// -- Numeric/tracker patterns --

/// Sonarr ReportTitleRegex[72]: Parser.cs:357-358
/// Spanish tracker: Cap.111
pub static REGEX_72: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:(?:[-_. ]+?Temporada.+?|\[.+?\])\[Cap)(?:[-_. ]+(?P<season>\d{1,2})(?P<ep>[1-9][0-9]|0[1-9]))+(?:\])")
        .expect("REGEX_72")
});

/// Sonarr ReportTitleRegex[73]: Parser.cs:361-362
/// 103/113 naming
///
/// C# separator is `[_.-]` (dot, underscore, dash only — NOT spaces).
/// C# `(?<![()[\]!])` lookbehind → dropped, handled by the character class.
/// C# `(?![a-z]|\d+)` after episode: dropped, validated post-match.
/// C# trailing `(?:[_.]|$)` — dot, underscore, or end of string.
pub static REGEX_73: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)^(?P<title>.+?)?(?:[_.-]+(?P<season>[1-9])(?P<ep>[1-9][0-9]|0[1-9]))+(?:[_.]|$)",
    )
    .expect("REGEX_73")
});

/// Sonarr ReportTitleRegex[74]: Parser.cs:366-367
/// 4-digit episode without title: S01E1234
///
/// C# `(?!i|p)` after 4-digit episode: prevents matching "1080p".
/// Replaced with `(?:[^ip]|$)` as a following context.
pub static REGEX_74: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)^(?:S?(?P<season>\d{1,2})(?:(?:[-ex]|\W[ex]|_){1,2}(?P<ep>\d{4}))+)(?:[^ip\d]|$)",
    )
    .expect("REGEX_74")
});

/// Sonarr ReportTitleRegex[75]: Parser.cs:371-372
/// 4-digit episode with title
pub static REGEX_75: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)(?:[^a-zA-Z0-9()\[\]!]+S?(?P<season>\d{1,2})(?:(?:[-ex]|\W[ex]|_){1,2}(?P<ep>\d{4}))+)(?:[^ip\d]|$)")
        .expect("REGEX_75")
});

/// Sonarr ReportTitleRegex[82]: Parser.cs:398-399
/// 1103/1113 naming
///
/// C# has `(?!\W\d+)` after episode to prevent year consumption. Greedy
/// title `.+` replaces that: matches the LAST 4-digit short, so years
/// like "2015" stay in the title when followed by a real episode "0308".
pub static REGEX_82: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+)[-_. ]+(?P<season>\d{2})(?P<ep>[1-9][0-9]|0[1-9])(?:[-_. ]+|$)")
        .expect("REGEX_82")
});

/// Sonarr ReportTitleRegex[83]: Parser.cs:402-403
/// Dutch/Flemish: Se.01 afl.01
pub static REGEX_83: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.+?)[-_. ](?:Se\.(?P<season>\d{1,2}|\d{4})(?:(?:[-_ ]?afl\.)(?P<ep1>\d{1,3})(?:(?:[-]|[-_ ]en[-_ ])(?P<ep2>\d{1,3}))*))")
        .expect("REGEX_83")
});

/// Sonarr ReportTitleRegex[84]: Parser.cs:406-407
/// Single-digit episode: S01E1
pub static REGEX_84: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?P<title>.*?)(?:[^a-zA-Z0-9()\[\]!]+S?(?P<season>\d{1,2})(?:(?:[-ex]){1,2}(?P<ep>\d))+)+(?:\W+|_|$)")
        .expect("REGEX_84")
});

/// Sonarr ReportTitleRegex[85]: Parser.cs:410-411
/// iTunes Season 1\05
pub static REGEX_85: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:Season(?:_|-|\s|\.)(?P<season>\d{1,2}))(?:_|-|\s|\.)(?P<ep>\d{1,2})")
        .expect("REGEX_85")
});

/// Sonarr ReportTitleRegex[86]: Parser.cs:414-415
/// iTunes 1-05
pub static REGEX_86: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:(?P<season>\d{1,2})(?:-(?P<ep>\d{2,3})))").expect("REGEX_86")
});

/// Sonarr ReportTitleRegex[95]: Parser.cs:450-451
/// Terrible multi-episode: extant.10708
pub static REGEX_95: Lazy<Regex> = Lazy::new(|| {
    Regex::new(
        r"(?i)^(?P<title>.+?)[-_. ](?P<season>[0]?\d?)(?:(?P<ep1>\d{2})(?P<ep2>\d{2}))[-_. ]",
    )
    .expect("REGEX_95")
});

/// Sonarr ReportTitleRegex[96]: Parser.cs:454-455
/// Season only for poorly named anime
pub static REGEX_96: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:\[.+?\][-_. ])?(?P<title>.+?)[-_. ]+?[(\[](?:S|Season|Saison|Series|Stagione)[-_. ]?(?P<season>\d{1,2})(?:[-_. )\]]|$)+(?P<extras>EXTRAS|SUBPACK)?")
        .expect("REGEX_96")
});

/// Sonarr ReportTitleRegex[97]: Parser.cs:458-459
/// Without title, single digit: S1E1, 1x1
pub static REGEX_97: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?i)^(?:S?(?P<season>\d{1,2}|\d{4})(?:(?:[-_ ]?[ex])(?P<ep>\d)))")
        .expect("REGEX_97")
});

/// The ordered cascade of all in-scope regexes. First match wins.
///
/// m53 cascade order mirrors Sonarr's `ReportTitleRegex[]` array.
pub static REPORT_TITLE_REGEXES: Lazy<Vec<IndexedRegex>> = Lazy::new(|| {
    vec![
        // Daily leading-date
        IndexedRegex {
            index: 0,
            regex: &REGEX_00,
        },
        IndexedRegex {
            index: 1,
            regex: &REGEX_01,
        },
        // Titleless
        IndexedRegex {
            index: 2,
            regex: &REGEX_02,
        },
        IndexedRegex {
            index: 3,
            regex: &REGEX_03,
        },
        IndexedRegex {
            index: 4,
            regex: &REGEX_04,
        },
        IndexedRegex {
            index: 5,
            regex: &REGEX_05,
        },
        IndexedRegex {
            index: 6,
            regex: &REGEX_06,
        },
        // Absolute/anime
        IndexedRegex {
            index: 7,
            regex: &REGEX_07,
        },
        IndexedRegex {
            index: 8,
            regex: &REGEX_08,
        },
        IndexedRegex {
            index: 10,
            regex: &REGEX_10,
        },
        IndexedRegex {
            index: 11,
            regex: &REGEX_11,
        },
        IndexedRegex {
            index: 12,
            regex: &REGEX_12,
        },
        IndexedRegex {
            index: 13,
            regex: &REGEX_13,
        },
        IndexedRegex {
            index: 14,
            regex: &REGEX_14,
        },
        IndexedRegex {
            index: 15,
            regex: &REGEX_15,
        },
        IndexedRegex {
            index: 16,
            regex: &REGEX_16,
        },
        IndexedRegex {
            index: 17,
            regex: &REGEX_17A,
        },
        IndexedRegex {
            index: 17,
            regex: &REGEX_17B,
        },
        IndexedRegex {
            index: 18,
            regex: &REGEX_18,
        },
        IndexedRegex {
            index: 19,
            regex: &REGEX_19,
        },
        IndexedRegex {
            index: 20,
            regex: &REGEX_20,
        },
        IndexedRegex {
            index: 21,
            regex: &REGEX_21,
        },
        // General [SubGroup] catch-all for absolute episodes (after dash-separated patterns)
        IndexedRegex {
            index: 17,
            regex: &REGEX_17C,
        },
        // With title — standard
        IndexedRegex {
            index: 22,
            regex: &REGEX_22,
        },
        IndexedRegex {
            index: 23,
            regex: &REGEX_23,
        },
        IndexedRegex {
            index: 24,
            regex: &REGEX_24,
        },
        IndexedRegex {
            index: 25,
            regex: &REGEX_25,
        },
        IndexedRegex {
            index: 26,
            regex: &REGEX_26,
        },
        IndexedRegex {
            index: 27,
            regex: &REGEX_27,
        },
        IndexedRegex {
            index: 28,
            regex: &REGEX_28,
        },
        IndexedRegex {
            index: 29,
            regex: &REGEX_29,
        },
        IndexedRegex {
            index: 30,
            regex: &REGEX_30,
        },
        IndexedRegex {
            index: 31,
            regex: &REGEX_31,
        },
        IndexedRegex {
            index: 32,
            regex: &REGEX_32,
        },
        IndexedRegex {
            index: 33,
            regex: &REGEX_33,
        },
        IndexedRegex {
            index: 34,
            regex: &REGEX_34,
        },
        IndexedRegex {
            index: 35,
            regex: &REGEX_35,
        },
        IndexedRegex {
            index: 36,
            regex: &REGEX_36,
        },
        IndexedRegex {
            index: 37,
            regex: &REGEX_37,
        },
        IndexedRegex {
            index: 38,
            regex: &REGEX_38,
        },
        IndexedRegex {
            index: 39,
            regex: &REGEX_39,
        },
        IndexedRegex {
            index: 40,
            regex: &REGEX_40,
        },
        IndexedRegex {
            index: 41,
            regex: &REGEX_41,
        },
        IndexedRegex {
            index: 42,
            regex: &REGEX_42,
        },
        IndexedRegex {
            index: 43,
            regex: &REGEX_43,
        },
        IndexedRegex {
            index: 44,
            regex: &REGEX_44,
        },
        IndexedRegex {
            index: 45,
            regex: &REGEX_45,
        },
        IndexedRegex {
            index: 46,
            regex: &REGEX_46,
        },
        // Mini-series
        IndexedRegex {
            index: 47,
            regex: &REGEX_47,
        },
        IndexedRegex {
            index: 48,
            regex: &REGEX_48,
        },
        // Daily with part
        IndexedRegex {
            index: 49,
            regex: &REGEX_49,
        },
        IndexedRegex {
            index: 50,
            regex: &REGEX_50,
        },
        IndexedRegex {
            index: 51,
            regex: &REGEX_51,
        },
        IndexedRegex {
            index: 52,
            regex: &REGEX_52,
        },
        // Season/Episode with title
        IndexedRegex {
            index: 53,
            regex: &REGEX_53,
        },
        IndexedRegex {
            index: 54,
            regex: &REGEX_54,
        },
        IndexedRegex {
            index: 55,
            regex: &REGEX_55,
        },
        IndexedRegex {
            index: 56,
            regex: &REGEX_56,
        },
        IndexedRegex {
            index: 57,
            regex: &REGEX_57,
        },
        IndexedRegex {
            index: 59,
            regex: &REGEX_59,
        },
        IndexedRegex {
            index: 60,
            regex: &REGEX_60,
        },
        IndexedRegex {
            index: 61,
            regex: &REGEX_61,
        },
        IndexedRegex {
            index: 62,
            regex: &REGEX_62,
        },
        IndexedRegex {
            index: 63,
            regex: &REGEX_63,
        },
        IndexedRegex {
            index: 64,
            regex: &REGEX_64,
        },
        // Anime with season-in-title
        IndexedRegex {
            index: 65,
            regex: &REGEX_65,
        },
        IndexedRegex {
            index: 66,
            regex: &REGEX_66,
        },
        IndexedRegex {
            index: 67,
            regex: &REGEX_67,
        },
        // Japanese variety shows
        IndexedRegex {
            index: 68,
            regex: &REGEX_68,
        },
        // Season-only
        IndexedRegex {
            index: 69,
            regex: &REGEX_69,
        },
        IndexedRegex {
            index: 70,
            regex: &REGEX_70,
        },
        IndexedRegex {
            index: 71,
            regex: &REGEX_71,
        },
        // Numeric/tracker
        IndexedRegex {
            index: 72,
            regex: &REGEX_72,
        },
        IndexedRegex {
            index: 73,
            regex: &REGEX_73,
        },
        IndexedRegex {
            index: 74,
            regex: &REGEX_74,
        },
        IndexedRegex {
            index: 75,
            regex: &REGEX_75,
        },
        // Main daily
        IndexedRegex {
            index: 76,
            regex: &REGEX_76,
        },
        IndexedRegex {
            index: 77,
            regex: &REGEX_77,
        },
        // Ambiguous dates
        IndexedRegex {
            index: 78,
            regex: &REGEX_78,
        },
        IndexedRegex {
            index: 79,
            regex: &REGEX_79,
        },
        IndexedRegex {
            index: 80,
            regex: &REGEX_80,
        },
        // Late absolute
        IndexedRegex {
            index: 81,
            regex: &REGEX_81,
        },
        IndexedRegex {
            index: 82,
            regex: &REGEX_82,
        },
        IndexedRegex {
            index: 83,
            regex: &REGEX_83,
        },
        IndexedRegex {
            index: 84,
            regex: &REGEX_84,
        },
        IndexedRegex {
            index: 85,
            regex: &REGEX_85,
        },
        IndexedRegex {
            index: 86,
            regex: &REGEX_86,
        },
        // Anime ranges and catch-alls
        IndexedRegex {
            index: 87,
            regex: &REGEX_87,
        },
        IndexedRegex {
            index: 88,
            regex: &REGEX_88,
        },
        IndexedRegex {
            index: 89,
            regex: &REGEX_89,
        },
        IndexedRegex {
            index: 90,
            regex: &REGEX_90,
        },
        IndexedRegex {
            index: 91,
            regex: &REGEX_91,
        },
        IndexedRegex {
            index: 92,
            regex: &REGEX_92,
        },
        IndexedRegex {
            index: 93,
            regex: &REGEX_93,
        },
        IndexedRegex {
            index: 94,
            regex: &REGEX_94,
        },
        // Terrible multi + season-only for anime
        IndexedRegex {
            index: 95,
            regex: &REGEX_95,
        },
        IndexedRegex {
            index: 96,
            regex: &REGEX_96,
        },
        IndexedRegex {
            index: 97,
            regex: &REGEX_97,
        },
    ]
});