avatarr-parser 0.1.0

// Ported from Sonarr v4.0.17.2952 (97e85a90):
//   src/NzbDrone.Core/Languages/Language.cs
//   src/NzbDrone.Core/Parser/IsoLanguage.cs
//   src/NzbDrone.Core/Parser/IsoLanguages.cs
//   src/NzbDrone.Core/Organizer/FileNameBuilder.cs (Iso639BTMap fragment only)
//
// **Relationship to `avatarr_core::Language`:** the integer IDs in this enum
// are intentionally identical to `crates/core/src/domain/language.rs`'s
// `Language(i32)` newtype. T11+ will build a `From<Language>` / reverse-map
// bridge between the two; for now `parser_lang as i32 -> core::Language(i)`
// is the contract.

pub mod parser;
pub mod subtitle;

pub use parser::parse_languages;
pub use subtitle::{
    SubtitleTitleInfo, parse_basic_subtitle, parse_language_tags, parse_subtitle_language,
    parse_subtitle_language_information,
};

/// Spoken / written language identifier with a stable integer ID.
///
/// IDs match Sonarr's `Language.cs` static initializers verbatim: 46
/// contiguous positive variants from `English = 1` through
/// `Slovenian = 46`, plus `Unknown = 0` and the sentinel `Original = -2`
/// used by Sonarr's quality-profile machinery to mean "the series'
/// original audio language", whatever that resolves to at the time.
///
/// Total: 48 variants (the m50 plan-spec drafted "47" but C#
/// `Language.cs:122-178` actually contains 48 entries; standing
/// rule #1 says C# fidelity wins). See the C# `All` list ordering:
/// every variant here matches the order in that list, with `Original`
/// last as in C#.
#[repr(i32)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum Language {
    #[default]
    Unknown = 0,
    English = 1,
    French = 2,
    Spanish = 3,
    German = 4,
    Italian = 5,
    Danish = 6,
    Dutch = 7,
    Japanese = 8,
    Icelandic = 9,
    Chinese = 10,
    Russian = 11,
    Polish = 12,
    Vietnamese = 13,
    Swedish = 14,
    Norwegian = 15,
    Finnish = 16,
    Turkish = 17,
    Portuguese = 18,
    Flemish = 19,
    Greek = 20,
    Korean = 21,
    Hungarian = 22,
    Hebrew = 23,
    Lithuanian = 24,
    Czech = 25,
    Arabic = 26,
    Hindi = 27,
    Bulgarian = 28,
    Malayalam = 29,
    Ukrainian = 30,
    Slovak = 31,
    Thai = 32,
    PortugueseBrazil = 33,
    SpanishLatino = 34,
    Romanian = 35,
    Latvian = 36,
    Persian = 37,
    Catalan = 38,
    Croatian = 39,
    Serbian = 40,
    Bosnian = 41,
    Estonian = 42,
    Tamil = 43,
    Indonesian = 44,
    Macedonian = 45,
    Slovenian = 46,
    Original = -2,
}

impl From<Language> for i32 {
    fn from(lang: Language) -> i32 {
        lang as i32
    }
}

impl Language {
    /// Display name as Sonarr stores it (e.g. `"Portuguese (Brazil)"`).
    ///
    /// Mirrors the second arg to each `new Language(id, name)` in
    /// `Language.cs`. Used by upcoming `parse_language_name` flows for
    /// reverse lookup; T11+ wires it in.
    pub fn name(self) -> &'static str {
        match self {
            Language::Unknown => "Unknown",
            Language::English => "English",
            Language::French => "French",
            Language::Spanish => "Spanish",
            Language::German => "German",
            Language::Italian => "Italian",
            Language::Danish => "Danish",
            Language::Dutch => "Dutch",
            Language::Japanese => "Japanese",
            Language::Icelandic => "Icelandic",
            Language::Chinese => "Chinese",
            Language::Russian => "Russian",
            Language::Polish => "Polish",
            Language::Vietnamese => "Vietnamese",
            Language::Swedish => "Swedish",
            Language::Norwegian => "Norwegian",
            Language::Finnish => "Finnish",
            Language::Turkish => "Turkish",
            Language::Portuguese => "Portuguese",
            Language::Flemish => "Flemish",
            Language::Greek => "Greek",
            Language::Korean => "Korean",
            Language::Hungarian => "Hungarian",
            Language::Hebrew => "Hebrew",
            Language::Lithuanian => "Lithuanian",
            Language::Czech => "Czech",
            Language::Arabic => "Arabic",
            Language::Hindi => "Hindi",
            Language::Bulgarian => "Bulgarian",
            Language::Malayalam => "Malayalam",
            Language::Ukrainian => "Ukrainian",
            Language::Slovak => "Slovak",
            Language::Thai => "Thai",
            Language::PortugueseBrazil => "Portuguese (Brazil)",
            Language::SpanishLatino => "Spanish (Latino)",
            Language::Romanian => "Romanian",
            Language::Latvian => "Latvian",
            Language::Persian => "Persian",
            Language::Catalan => "Catalan",
            Language::Croatian => "Croatian",
            Language::Serbian => "Serbian",
            Language::Bosnian => "Bosnian",
            Language::Estonian => "Estonian",
            Language::Tamil => "Tamil",
            Language::Indonesian => "Indonesian",
            Language::Macedonian => "Macedonian",
            Language::Slovenian => "Slovenian",
            Language::Original => "Original",
        }
    }
}

/// ISO-639 code lookup table + `find()` entrypoint.
///
/// Mirrors Sonarr's `IsoLanguages.cs` static `All` HashSet and `Find`
/// algorithm verbatim. The `IsoLanguage` record carries the original
/// 4-tuple shape (two-letter, country, three-letter, Language) so a
/// future caller that needs the full record can graduate from the
/// `find` shortcut to `find_iso`.
pub mod iso_languages {
    use super::Language;

    /// One row of Sonarr's `IsoLanguages.All`: ISO-639-1 (2-letter),
    /// optional ISO-3166 country code, ISO-639-2/T (3-letter), and the
    /// `Language` it identifies.
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[non_exhaustive]
    pub struct IsoLanguage {
        pub two_letter_code: &'static str,
        pub country_code: &'static str,
        pub three_letter_code: &'static str,
        pub language: Language,
    }

    /// Static lookup table. Order matters because Sonarr's `Find`
    /// returns `FirstOrDefault()` when multiple rows match. In
    /// particular, `("nl", "", "nld", Dutch)` precedes
    /// `("nl", "", "nld", Flemish)`, so a bare `nl` resolves to Dutch.
    /// Likewise `("pt", "pt", ...)` precedes `("pt", "br", ...)`.
    const ALL: &[IsoLanguage] = &[
        IsoLanguage {
            two_letter_code: "en",
            country_code: "",
            three_letter_code: "eng",
            language: Language::English,
        },
        IsoLanguage {
            two_letter_code: "fr",
            country_code: "fr",
            three_letter_code: "fra",
            language: Language::French,
        },
        IsoLanguage {
            two_letter_code: "es",
            country_code: "",
            three_letter_code: "spa",
            language: Language::Spanish,
        },
        IsoLanguage {
            two_letter_code: "de",
            country_code: "de",
            three_letter_code: "deu",
            language: Language::German,
        },
        IsoLanguage {
            two_letter_code: "it",
            country_code: "",
            three_letter_code: "ita",
            language: Language::Italian,
        },
        IsoLanguage {
            two_letter_code: "da",
            country_code: "",
            three_letter_code: "dan",
            language: Language::Danish,
        },
        IsoLanguage {
            two_letter_code: "nl",
            country_code: "",
            three_letter_code: "nld",
            language: Language::Dutch,
        },
        IsoLanguage {
            two_letter_code: "ja",
            country_code: "",
            three_letter_code: "jpn",
            language: Language::Japanese,
        },
        IsoLanguage {
            two_letter_code: "is",
            country_code: "",
            three_letter_code: "isl",
            language: Language::Icelandic,
        },
        IsoLanguage {
            two_letter_code: "zh",
            country_code: "cn",
            three_letter_code: "zho",
            language: Language::Chinese,
        },
        IsoLanguage {
            two_letter_code: "ru",
            country_code: "",
            three_letter_code: "rus",
            language: Language::Russian,
        },
        IsoLanguage {
            two_letter_code: "pl",
            country_code: "",
            three_letter_code: "pol",
            language: Language::Polish,
        },
        IsoLanguage {
            two_letter_code: "vi",
            country_code: "",
            three_letter_code: "vie",
            language: Language::Vietnamese,
        },
        IsoLanguage {
            two_letter_code: "sv",
            country_code: "",
            three_letter_code: "swe",
            language: Language::Swedish,
        },
        IsoLanguage {
            two_letter_code: "no",
            country_code: "",
            three_letter_code: "nor",
            language: Language::Norwegian,
        },
        // Norwegian Bokmal: 2-letter "nb" maps to the same Language::Norwegian.
        IsoLanguage {
            two_letter_code: "nb",
            country_code: "",
            three_letter_code: "nob",
            language: Language::Norwegian,
        },
        IsoLanguage {
            two_letter_code: "fi",
            country_code: "",
            three_letter_code: "fin",
            language: Language::Finnish,
        },
        IsoLanguage {
            two_letter_code: "tr",
            country_code: "",
            three_letter_code: "tur",
            language: Language::Turkish,
        },
        IsoLanguage {
            two_letter_code: "pt",
            country_code: "pt",
            three_letter_code: "por",
            language: Language::Portuguese,
        },
        // Flemish shares "nl" + "nld" with Dutch; Dutch precedes so a bare "nl" / "nld" resolves to Dutch.
        IsoLanguage {
            two_letter_code: "nl",
            country_code: "",
            three_letter_code: "nld",
            language: Language::Flemish,
        },
        IsoLanguage {
            two_letter_code: "el",
            country_code: "",
            three_letter_code: "ell",
            language: Language::Greek,
        },
        IsoLanguage {
            two_letter_code: "ko",
            country_code: "",
            three_letter_code: "kor",
            language: Language::Korean,
        },
        IsoLanguage {
            two_letter_code: "hu",
            country_code: "",
            three_letter_code: "hun",
            language: Language::Hungarian,
        },
        IsoLanguage {
            two_letter_code: "he",
            country_code: "",
            three_letter_code: "heb",
            language: Language::Hebrew,
        },
        IsoLanguage {
            two_letter_code: "lt",
            country_code: "",
            three_letter_code: "lit",
            language: Language::Lithuanian,
        },
        IsoLanguage {
            two_letter_code: "cs",
            country_code: "",
            three_letter_code: "ces",
            language: Language::Czech,
        },
        IsoLanguage {
            two_letter_code: "ar",
            country_code: "",
            three_letter_code: "ara",
            language: Language::Arabic,
        },
        IsoLanguage {
            two_letter_code: "hi",
            country_code: "",
            three_letter_code: "hin",
            language: Language::Hindi,
        },
        IsoLanguage {
            two_letter_code: "bg",
            country_code: "",
            three_letter_code: "bul",
            language: Language::Bulgarian,
        },
        IsoLanguage {
            two_letter_code: "ml",
            country_code: "",
            three_letter_code: "mal",
            language: Language::Malayalam,
        },
        IsoLanguage {
            two_letter_code: "uk",
            country_code: "",
            three_letter_code: "ukr",
            language: Language::Ukrainian,
        },
        IsoLanguage {
            two_letter_code: "sk",
            country_code: "",
            three_letter_code: "slk",
            language: Language::Slovak,
        },
        IsoLanguage {
            two_letter_code: "th",
            country_code: "th",
            three_letter_code: "tha",
            language: Language::Thai,
        },
        IsoLanguage {
            two_letter_code: "pt",
            country_code: "br",
            three_letter_code: "por",
            language: Language::PortugueseBrazil,
        },
        IsoLanguage {
            two_letter_code: "es",
            country_code: "mx",
            three_letter_code: "spa",
            language: Language::SpanishLatino,
        },
        IsoLanguage {
            two_letter_code: "ro",
            country_code: "",
            three_letter_code: "ron",
            language: Language::Romanian,
        },
        IsoLanguage {
            two_letter_code: "lv",
            country_code: "",
            three_letter_code: "lav",
            language: Language::Latvian,
        },
        IsoLanguage {
            two_letter_code: "fa",
            country_code: "",
            three_letter_code: "fas",
            language: Language::Persian,
        },
        IsoLanguage {
            two_letter_code: "ca",
            country_code: "",
            three_letter_code: "cat",
            language: Language::Catalan,
        },
        IsoLanguage {
            two_letter_code: "hr",
            country_code: "",
            three_letter_code: "hrv",
            language: Language::Croatian,
        },
        IsoLanguage {
            two_letter_code: "sr",
            country_code: "",
            three_letter_code: "srp",
            language: Language::Serbian,
        },
        IsoLanguage {
            two_letter_code: "bs",
            country_code: "",
            three_letter_code: "bos",
            language: Language::Bosnian,
        },
        IsoLanguage {
            two_letter_code: "et",
            country_code: "",
            three_letter_code: "est",
            language: Language::Estonian,
        },
        IsoLanguage {
            two_letter_code: "ta",
            country_code: "",
            three_letter_code: "tam",
            language: Language::Tamil,
        },
        IsoLanguage {
            two_letter_code: "id",
            country_code: "",
            three_letter_code: "ind",
            language: Language::Indonesian,
        },
        IsoLanguage {
            two_letter_code: "mk",
            country_code: "",
            three_letter_code: "mkd",
            language: Language::Macedonian,
        },
        IsoLanguage {
            two_letter_code: "sl",
            country_code: "",
            three_letter_code: "slv",
            language: Language::Slovenian,
        },
    ];

    /// Sonarr's `AlternateIsoCodeMappings` dictionary: shortcut three-
    /// to-five-letter codes that don't follow the ISO-639 / ISO-3166
    /// scheme and map directly to a `Language`. Looked up against the
    /// raw (post-lowercase) input, before the 3-letter ISO-639-2/T
    /// fallback in `find`.
    const ALTERNATE: &[(&str, Language)] = &[
        ("cze", Language::Czech),
        ("dut", Language::Dutch),
        ("mac", Language::Macedonian),
        ("rum", Language::Romanian),
        ("yue", Language::Chinese),
        ("zhtw", Language::Chinese),
    ];

    /// Sonarr's `Iso639BTMap` (from `Organizer/FileNameBuilder.cs`):
    /// ISO-639-2/B (bibliographic) to ISO-639-2/T (terminological).
    /// Sonarr applies this before the 3-letter lookup so a B-form
    /// release tag like `fre` finds French via its T-form `fra`. Only
    /// the entries Sonarr actually ships are here. None of the keys
    /// collide with our `ALTERNATE` table because that fires earlier.
    const B_TO_T_MAP: &[(&str, &str)] = &[
        ("alb", "sqi"),
        ("arm", "hye"),
        ("baq", "eus"),
        ("bur", "mya"),
        ("chi", "zho"),
        ("cze", "ces"),
        ("dut", "nld"),
        ("fre", "fra"),
        ("geo", "kat"),
        ("ger", "deu"),
        ("gre", "ell"),
        ("ice", "isl"),
        ("mac", "mkd"),
        ("mao", "mri"),
        ("may", "msa"),
        ("per", "fas"),
        ("rum", "ron"),
        ("slo", "slk"),
        ("tib", "bod"),
        ("wel", "cym"),
    ];

    /// Resolve an ISO-639 / locale code to a `Language`. Mirrors
    /// Sonarr's `IsoLanguages.Find` algorithm:
    ///
    /// 1. Lowercase + split on `-`. The part before `-` is `langCode`.
    /// 2. If `langCode` is 2 letters: filter `ALL` by `two_letter_code`.
    ///    With a country part, prefer rows whose `country_code` matches;
    ///    if none match, narrow to rows with empty `country_code`. With
    ///    no country part, return the first matching row.
    /// 3. If the full lowercased input is in `ALTERNATE`, return that.
    /// 4. If `langCode` is 3 letters: apply `B_TO_T_MAP` if present,
    ///    then look up by `three_letter_code`.
    /// 5. Anything else (4+, or 0 letters): `None`.
    ///
    /// The shortcut return type is `Option<Language>` rather than
    /// `Option<IsoLanguage>` because every current consumer wants the
    /// `Language` only. `find_iso` is the richer entrypoint.
    ///
    /// # Case-sensitivity note
    ///
    /// This function lowercases input before consulting the alternate map. C#'s
    /// `IsoLanguages.Find` (Parser/IsoLanguages.cs:91) is case-sensitive on the
    /// alternate-map lookup. All in-tree C# call sites pre-lowercase the input,
    /// so the divergence is unreachable in practice; the more conservative Rust
    /// behaviour widens the function's input space without affecting outputs
    /// for any existing caller.
    pub fn find(code: &str) -> Option<Language> {
        find_iso(code).map(|iso| iso.language)
    }

    /// Same algorithm as [`find`] but returns the full `IsoLanguage`
    /// record (so callers can read the original ISO codes back, e.g.
    /// for reverse-mapping `PortugueseBrazil` to `pt-br`).
    pub fn find_iso(code: &str) -> Option<IsoLanguage> {
        let lowered = code.to_ascii_lowercase();
        let (lang_code, country_code) = match lowered.split_once('-') {
            Some((l, c)) => (l, Some(c)),
            None => (lowered.as_str(), None),
        };

        match lang_code.len() {
            2 => find_two_letter(lang_code, country_code),
            3 => {
                // Alternate map matches the full lowered code, not
                // just `lang_code`. Sonarr does the alternate lookup
                // before the 3-letter ISO-639-2 lookup.
                if let Some(lang) = alternate_lookup(&lowered) {
                    return canonical_row(lang);
                }
                find_three_letter(lang_code)
            }
            // `len() != 2 && != 3` still has to consult the alternate
            // map: `zhtw` is 4 letters but lives there.
            _ => alternate_lookup(&lowered).and_then(canonical_row),
        }
    }

    fn find_two_letter(lang_code: &str, country_code: Option<&str>) -> Option<IsoLanguage> {
        let matches: Vec<&IsoLanguage> = ALL
            .iter()
            .filter(|l| l.two_letter_code == lang_code)
            .collect();

        if matches.is_empty() {
            return None;
        }

        match country_code {
            None => matches.first().copied().copied(),
            Some(country) => {
                // Prefer rows whose country code matches.
                let any_country_match = matches.iter().any(|l| l.country_code == country);
                if any_country_match {
                    matches
                        .iter()
                        .find(|l| l.country_code == country)
                        .copied()
                        .copied()
                } else {
                    // Fall back to rows with empty country code.
                    matches
                        .iter()
                        .find(|l| l.country_code.is_empty())
                        .copied()
                        .copied()
                }
            }
        }
    }

    fn find_three_letter(lang_code: &str) -> Option<IsoLanguage> {
        let mapped = B_TO_T_MAP
            .iter()
            .find_map(|(b, t)| (*b == lang_code).then_some(*t))
            .unwrap_or(lang_code);
        ALL.iter().find(|l| l.three_letter_code == mapped).copied()
    }

    fn alternate_lookup(lowered: &str) -> Option<Language> {
        ALTERNATE
            .iter()
            .find_map(|(code, lang)| (*code == lowered).then_some(*lang))
    }

    /// Find the canonical `IsoLanguage` row in `ALL` for a given
    /// `Language`. Mirrors C# `IsoLanguages.Get` (Parser/IsoLanguages.cs:109-112)
    /// which is `All.FirstOrDefault(l => l.Language == language)`.
    ///
    /// Used by [`find_iso`] on the alternate-map path: the alternate
    /// dict only carries the `Language`, so we have to walk back to
    /// `ALL` to recover the canonical 2/3-letter codes.
    ///
    /// Returns `None` if the language has no entry in `ALL` — Sonarr's
    /// equivalent returns a default `IsoLanguage()` in that case but
    /// this branch is unreachable in practice. Several `B_TO_T_MAP`
    /// targets (`sqi`/`hye`/`eus`/`mya`/`kat`/`mri`/`msa`/`bod`/`cym`)
    /// do not appear in `ALL`, but those flow through `find_three_letter`,
    /// not the alternate path; every entry in `ALTERNATE` points at a
    /// `Language` that has at least one row in `ALL`.
    fn canonical_row(language: Language) -> Option<IsoLanguage> {
        ALL.iter().find(|l| l.language == language).copied()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // --- Plan-required tests ---------------------------------------

    #[test]
    fn language_constants_have_expected_ids() {
        assert_eq!(Language::Unknown as i32, 0);
        assert_eq!(Language::English as i32, 1);
        assert_eq!(Language::SpanishLatino as i32, 34);
        assert_eq!(Language::Slovenian as i32, 46);
        assert_eq!(Language::Original as i32, -2);
    }

    #[test]
    fn iso_languages_finds_eng() {
        assert_eq!(iso_languages::find("eng"), Some(Language::English));
    }

    #[test]
    fn iso_languages_finds_fre() {
        // "fre" is the ISO-639-2/B form of French; B-to-T map sends it to "fra".
        assert_eq!(iso_languages::find("fre"), Some(Language::French));
    }

    #[test]
    fn iso_languages_unknown_for_garbage() {
        assert_eq!(iso_languages::find("zzz"), None);
    }

    // --- C# IsoLanguagesFixture parity -----------------------------

    #[test]
    fn english_resolves_via_two_letter_three_letter_and_locale() {
        for code in ["en", "eng", "en-US", "en-GB"] {
            assert_eq!(
                iso_languages::find(code),
                Some(Language::English),
                "code = {code}"
            );
        }
    }

    #[test]
    fn unknown_or_invalid_codes_return_none() {
        // Mirrors C# IsoLanguagesFixture.unknown_or_invalid_code_should_return_null.
        for code in ["enus", "enusa", "wo", "fr-CA"] {
            assert_eq!(iso_languages::find(code), None, "code = {code}");
        }
    }

    #[test]
    fn portuguese_resolves_via_two_letter_three_letter_and_locale() {
        for code in ["pt", "por", "pt-PT"] {
            assert_eq!(
                iso_languages::find(code),
                Some(Language::Portuguese),
                "code = {code}"
            );
        }
    }

    #[test]
    fn de_au_returns_none_because_german_requires_de_country_code() {
        // German entry has CountryCode="de"; no fallback row with empty
        // country code exists for "de", so de-AU yields None.
        assert_eq!(iso_languages::find("de-AU"), None);
    }

    #[test]
    fn cze_resolves_via_alternate_iso_code_mapping() {
        assert_eq!(iso_languages::find("cze"), Some(Language::Czech));
    }

    // --- Additional coverage of the algorithm ----------------------

    #[test]
    fn pt_br_resolves_to_portuguese_brazil() {
        assert_eq!(
            iso_languages::find("pt-br"),
            Some(Language::PortugueseBrazil)
        );
        // Case-insensitive on both halves.
        assert_eq!(
            iso_languages::find("pt-BR"),
            Some(Language::PortugueseBrazil)
        );
    }

    #[test]
    fn es_mx_resolves_to_spanish_latino_but_bare_es_to_spanish() {
        assert_eq!(iso_languages::find("es"), Some(Language::Spanish));
        assert_eq!(iso_languages::find("es-mx"), Some(Language::SpanishLatino));
    }

    #[test]
    fn bare_nl_resolves_to_dutch_not_flemish() {
        // Both Dutch and Flemish map to ("nl", "", "nld"); Dutch is
        // listed first in ALL, so FirstOrDefault returns Dutch.
        assert_eq!(iso_languages::find("nl"), Some(Language::Dutch));
        assert_eq!(iso_languages::find("nld"), Some(Language::Dutch));
    }

    #[test]
    fn b_to_t_map_resolves_old_ger_form_to_german() {
        assert_eq!(iso_languages::find("ger"), Some(Language::German));
        assert_eq!(iso_languages::find("deu"), Some(Language::German));
    }

    #[test]
    fn alternate_zhtw_resolves_to_chinese() {
        // Four-letter alternate code; only path that hits the >3-letter
        // arm of the algorithm.
        assert_eq!(iso_languages::find("zhtw"), Some(Language::Chinese));
    }

    #[test]
    fn nb_two_letter_resolves_to_norwegian() {
        // Norwegian Bokmal entry wires to the same Language::Norwegian.
        assert_eq!(iso_languages::find("nb"), Some(Language::Norwegian));
        assert_eq!(iso_languages::find("nob"), Some(Language::Norwegian));
    }

    #[test]
    fn case_is_normalised() {
        assert_eq!(iso_languages::find("ENG"), Some(Language::English));
        assert_eq!(iso_languages::find("Fr"), Some(Language::French));
    }

    #[test]
    fn empty_and_oversized_codes_return_none() {
        assert_eq!(iso_languages::find(""), None);
        assert_eq!(iso_languages::find("english"), None);
    }

    #[test]
    fn language_default_is_unknown() {
        assert_eq!(Language::default(), Language::Unknown);
    }

    #[test]
    fn language_name_round_trips_for_brazil_and_latino() {
        assert_eq!(Language::PortugueseBrazil.name(), "Portuguese (Brazil)");
        assert_eq!(Language::SpanishLatino.name(), "Spanish (Latino)");
        assert_eq!(Language::Original.name(), "Original");
    }

    #[test]
    fn find_iso_returns_full_record_for_canonical_codes() {
        let iso = iso_languages::find_iso("pt-br").expect("pt-br must resolve");
        assert_eq!(iso.language, Language::PortugueseBrazil);
        assert_eq!(iso.two_letter_code, "pt");
        assert_eq!(iso.country_code, "br");
        assert_eq!(iso.three_letter_code, "por");
    }

    #[test]
    fn find_iso_alternate_hit_returns_canonical_row_not_synthetic() {
        // C# IsoLanguages.Find calls Get(language) on alternate hits,
        // which canonicalizes to the ALL-table row. The Rust port previously
        // synthesized empty codes; this test guards the fix.
        let cze = iso_languages::find_iso("cze").expect("alternate hit");
        assert_eq!(cze.language, Language::Czech);
        assert_eq!(cze.three_letter_code, "ces"); // canonical form, not empty
        assert_eq!(cze.two_letter_code, "cs"); // canonical form, not empty
    }

    #[test]
    fn from_language_to_i32_preserves_id() {
        assert_eq!(i32::from(Language::English), 1);
        assert_eq!(i32::from(Language::Original), -2);
        assert_eq!(i32::from(Language::Slovenian), 46);
    }

    /// Sonarr's `All` list has 48 entries: `Unknown = 0`, 46 contiguous
    /// positive variants (`English = 1` through `Slovenian = 46`), and
    /// the `Original = -2` sentinel. The m50 plan-spec stated "47", but
    /// counting the C# `All` initializer in `Language.cs:122-178`
    /// yields 48; standing rule #1 says C# fidelity wins.
    ///
    /// This test catches accidental drift if anyone reorders or drops
    /// a variant.
    #[test]
    fn enum_has_exactly_48_variants_with_contiguous_ids() {
        // We can't introspect the enum at runtime, so list every
        // variant explicitly. A new variant added without updating
        // this test is fine; a removed or renumbered variant trips it.
        let all: &[Language] = &[
            Language::Unknown,
            Language::English,
            Language::French,
            Language::Spanish,
            Language::German,
            Language::Italian,
            Language::Danish,
            Language::Dutch,
            Language::Japanese,
            Language::Icelandic,
            Language::Chinese,
            Language::Russian,
            Language::Polish,
            Language::Vietnamese,
            Language::Swedish,
            Language::Norwegian,
            Language::Finnish,
            Language::Turkish,
            Language::Portuguese,
            Language::Flemish,
            Language::Greek,
            Language::Korean,
            Language::Hungarian,
            Language::Hebrew,
            Language::Lithuanian,
            Language::Czech,
            Language::Arabic,
            Language::Hindi,
            Language::Bulgarian,
            Language::Malayalam,
            Language::Ukrainian,
            Language::Slovak,
            Language::Thai,
            Language::PortugueseBrazil,
            Language::SpanishLatino,
            Language::Romanian,
            Language::Latvian,
            Language::Persian,
            Language::Catalan,
            Language::Croatian,
            Language::Serbian,
            Language::Bosnian,
            Language::Estonian,
            Language::Tamil,
            Language::Indonesian,
            Language::Macedonian,
            Language::Slovenian,
            Language::Original,
        ];
        assert_eq!(all.len(), 48);
        // Indices 0..=46 must equal the contiguous IDs Unknown..Slovenian.
        // Index 47 is Original (-2).
        for (idx, lang) in all.iter().enumerate() {
            if idx < 47 {
                assert_eq!(*lang as i32, idx as i32, "variant at index {idx}");
            } else {
                assert_eq!(*lang as i32, -2, "Original sentinel last");
            }
        }
    }
}